diff --git a/aosp/update_engine_client_android.cc b/aosp/update_engine_client_android.cc
index 81736a7..4f42a59 100644
--- a/aosp/update_engine_client_android.cc
+++ b/aosp/update_engine_client_android.cc
@@ -17,6 +17,7 @@
 #include <sysexits.h>
 #include <unistd.h>
 
+#include <chrono>
 #include <string>
 #include <vector>
 
@@ -344,7 +345,15 @@
 }  // namespace chromeos_update_engine
 
 int main(int argc, char** argv) {
+  const auto start = std::chrono::system_clock::now();
   chromeos_update_engine::internal::UpdateEngineClientAndroid client(argc,
                                                                      argv);
-  return client.Run();
+  const auto ret = client.Run();
+  const auto end = std::chrono::system_clock::now();
+  const auto duration = end - start;
+  LOG(INFO)
+      << "Command took "
+      << std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()
+      << " ms";
+  return ret;
 }
diff --git a/payload_consumer/block_extent_writer.cc b/payload_consumer/block_extent_writer.cc
index 456c491..1379277 100644
--- a/payload_consumer/block_extent_writer.cc
+++ b/payload_consumer/block_extent_writer.cc
@@ -69,8 +69,7 @@
   if (buffer_.empty() && count >= write_size) {
     if (!WriteExtent(data, write_size)) {
       LOG(ERROR) << "WriteExtent(" << cur_extent.start_block() << ", "
-                 << static_cast<const void*>(data) << ", " << write_size
-                 << ") failed.";
+                 << write_size << ") failed.";
       // return value is expected to be greater than 0. Return 0 to signal error
       // condition
       return 0;
@@ -92,9 +91,8 @@
 
   if (buffer_.size() == write_size) {
     if (!WriteExtent(buffer_.data(), write_size)) {
-      LOG(ERROR) << "WriteExtent(" << buffer_.data() << ", "
-                 << cur_extent.start_block() << ", " << cur_extent.num_blocks()
-                 << ") failed.";
+      LOG(ERROR) << "WriteExtent(" << cur_extent.start_block() << ", "
+                 << cur_extent.num_blocks() << ") failed.";
       return 0;
     }
     buffer_.clear();
diff --git a/payload_consumer/delta_performer.cc b/payload_consumer/delta_performer.cc
index 8a820f9..dcbf2cc 100644
--- a/payload_consumer/delta_performer.cc
+++ b/payload_consumer/delta_performer.cc
@@ -16,12 +16,11 @@
 
 #include "update_engine/payload_consumer/delta_performer.h"
 
-#include <errno.h>
 #include <linux/fs.h>
 
 #include <algorithm>
+#include <chrono>
 #include <cstring>
-#include <map>
 #include <memory>
 #include <set>
 #include <string>
@@ -791,10 +790,17 @@
     }
   }
 
+  const auto start = std::chrono::system_clock::now();
   if (!install_plan_->ParsePartitions(
           partitions_, boot_control_, block_size_, error)) {
     return false;
   }
+  const auto duration = std::chrono::system_clock::now() - start;
+  LOG(INFO)
+      << "ParsePartitions done. took "
+      << std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()
+      << " ms";
+
   auto&& has_verity = [](const auto& part) {
     return part.fec_extent().num_blocks() > 0 ||
            part.hash_tree_extent().num_blocks() > 0;
@@ -848,6 +854,7 @@
     ResetUpdateProgress(prefs, false);
   }
 
+  const auto start = std::chrono::system_clock::now();
   if (!boot_control->GetDynamicPartitionControl()->PreparePartitionsForUpdate(
           boot_control->GetCurrentSlot(),
           target_slot,
@@ -860,10 +867,14 @@
                << utils::ErrorCodeToString(*error);
     return false;
   }
+  const auto duration = std::chrono::system_clock::now() - start;
 
   TEST_AND_RETURN_FALSE(prefs->SetString(kPrefsDynamicPartitionMetadataUpdated,
                                          update_check_response_hash));
-  LOG(INFO) << "PreparePartitionsForUpdate done.";
+  LOG(INFO)
+      << "PreparePartitionsForUpdate done. took "
+      << std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()
+      << " ms";
 
   return true;
 }
@@ -1342,7 +1353,8 @@
   if (prefs->GetInt64(kPrefsResumedUpdateFailures, &resumed_update_failures) &&
       resumed_update_failures > kMaxResumedUpdateFailures) {
     LOG(WARNING) << "Failed to resume update " << kPrefsResumedUpdateFailures
-                 << " invalid: " << resumed_update_failures;
+                 << " has value " << resumed_update_failures
+                 << " is over the limit " << kMaxResumedUpdateFailures;
     return false;
   }