Add logging to remote commands

chrome/browser/chromeos/policy/system_log_uploader.cc

 // Copyright (c) 2015 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 <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/chromeos/logging.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/upload_job_impl.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
@@ skipping 24 matching lines @@
 // as pairs (file name, data) and returns. Called on blocking thread.
 std::unique_ptr<policy::SystemLogUploader::SystemLogs> ReadFiles() {
   std::unique_ptr<policy::SystemLogUploader::SystemLogs> system_logs(
       new policy::SystemLogUploader::SystemLogs());
   feedback::AnonymizerTool anonymizer;
   for (auto const file_path : kSystemLogFileNames) {
     if (!base::PathExists(base::FilePath(file_path)))
       continue;
     std::string data = std::string();
     if (!base::ReadFileToString(base::FilePath(file_path), &data)) {
-      LOG(ERROR) << "Failed to read the system log file from the disk "
-                 << file_path << std::endl;
+      CHROMEOS_SYSLOG(ERROR)
+          << "Failed to read the system log file from the disk " << file_path
+          << std::endl;
     }
     system_logs->push_back(std::make_pair(
         file_path,
         policy::SystemLogUploader::RemoveSensitiveData(&anonymizer, data)));
   }
   return system_logs;
 }
 
 // An implementation of the |SystemLogUploader::Delegate|, that is used to
 // create an upload job and load system logs from the disk.
@@ skipping 35 matching lines @@
 std::unique_ptr<policy::UploadJob> SystemLogDelegate::CreateUploadJob(
     const GURL& upload_url,
     policy::UploadJob::Delegate* delegate) {
   chromeos::DeviceOAuth2TokenService* device_oauth2_token_service =
       chromeos::DeviceOAuth2TokenServiceFactory::Get();
 
   scoped_refptr<net::URLRequestContextGetter> system_request_context =
       g_browser_process->system_request_context();
   std::string robot_account_id =
       device_oauth2_token_service->GetRobotAccountId();
+
+  CHROMEOS_SYSLOG(WARNING) << "Creating upload job for system log";
   return std::unique_ptr<policy::UploadJob>(new policy::UploadJobImpl(
       upload_url, robot_account_id, device_oauth2_token_service,
       system_request_context, delegate,
       base::WrapUnique(new policy::UploadJobImpl::RandomMimeBoundaryGenerator),
       task_runner_));
 }
 
 // Returns the system log upload frequency.
 base::TimeDelta GetUploadFrequency() {
   base::TimeDelta upload_frequency(base::TimeDelta::FromMilliseconds(
@@ skipping 65 matching lines @@
 
   // Immediately schedule the next system log upload (last_upload_attempt_ is
   // set to the start of the epoch, so this will trigger an update upload in the
   // immediate future).
   ScheduleNextSystemLogUpload(upload_frequency_);
 }
 
 SystemLogUploader::~SystemLogUploader() {}
 
 void SystemLogUploader::OnSuccess() {
+  CHROMEOS_SYSLOG(WARNING) << "Upload successful.";
   upload_job_.reset();
   last_upload_attempt_ = base::Time::NowFromSystemTime();
   retry_count_ = 0;
 
   // On successful log upload schedule the next log upload after
   // upload_frequency_ time from now.
   ScheduleNextSystemLogUpload(upload_frequency_);
 }
 
 void SystemLogUploader::OnFailure(UploadJob::ErrorCode error_code) {
   upload_job_.reset();
   last_upload_attempt_ = base::Time::NowFromSystemTime();
 
   //  If we have hit the maximum number of retries, terminate this upload
   //  attempt and schedule the next one using the normal delay. Otherwise, retry
   //  uploading after kErrorUploadDelayMs milliseconds.
   if (retry_count_++ < kMaxNumRetries) {
+    CHROMEOS_SYSLOG(ERROR) << "Upload failed with error code " << error_code
+                           << ", retrying later.";
     ScheduleNextSystemLogUpload(
         base::TimeDelta::FromMilliseconds(kErrorUploadDelayMs));
   } else {
     // No more retries.
+    CHROMEOS_SYSLOG(ERROR) << "Upload failed with error code " << error_code
+                           << ", no more retries.";
     retry_count_ = 0;
     ScheduleNextSystemLogUpload(upload_frequency_);
   }
 }
 
 // static
 std::string SystemLogUploader::RemoveSensitiveData(
     feedback::AnonymizerTool* const anonymizer,
     const std::string& data) {
   return anonymizer->Anonymize(data);
@@ skipping 66 matching lines @@
       base::TimeDelta());
   // Ensure that we never have more than one pending delayed task.
   weak_factory_.InvalidateWeakPtrs();
   task_runner_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&SystemLogUploader::StartLogUpload,
                                            weak_factory_.GetWeakPtr()),
                                 delay);
 }
 
 }  // namespace policy