Add Drive.MetadataDBValidityCheckFailureReason UMA histogram

chrome/browser/chromeos/drive/resource_metadata_storage.cc

 // Copyright 2013 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 "chrome/browser/chromeos/drive/resource_metadata_storage.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 19 matching lines @@
   DB_INIT_IO_ERROR,
   DB_INIT_FAILED,
   DB_INIT_INCOMPATIBLE,
   DB_INIT_BROKEN,
   DB_INIT_OPENED_EXISTING_DB,
   DB_INIT_CREATED_NEW_DB,
   DB_INIT_REPLACED_EXISTING_DB_WITH_NEW_DB,
   DB_INIT_MAX_VALUE,
 };
 
+// Enum to describe DB validity check failure reason.
+enum CheckValidityFailureReason {
+  CHECK_VALIDITY_FAILURE_INVALID_HEADER,
+  CHECK_VALIDITY_FAILURE_BROKEN_ID_ENTRY,
+  CHECK_VALIDITY_FAILURE_BROKEN_ENTRY,
+  CHECK_VALIDITY_FAILURE_INVALID_LOCAL_ID,
+  CHECK_VALIDITY_FAILURE_INVALID_PARENT_ID,
+  CHECK_VALIDITY_FAILURE_BROKEN_CHILD_MAP,
+  CHECK_VALIDITY_FAILURE_CHILD_ENTRY_COUNT_MISMATCH,
+  CHECK_VALIDITY_FAILURE_ITERATOR_ERROR,
+  CHECK_VALIDITY_FAILURE_MAX_VALUE,
+};
+
 // The name of the DB which stores the metadata.
 const base::FilePath::CharType kResourceMapDBName[] =
     FILE_PATH_LITERAL("resource_metadata_resource_map.db");
 
 // The name of the DB which couldn't be opened, but is preserved just in case.
 const base::FilePath::CharType kPreservedResourceMapDBName[] =
     FILE_PATH_LITERAL("resource_metadata_preserved_resource_map.db");
 
 // The name of the DB which couldn't be opened, and was replaced with a new one.
 const base::FilePath::CharType kTrashedResourceMapDBName[] =
@@ skipping 875 matching lines @@
   // "|ID of B|"                    : ResourceEntry for entry B.
   // ...
 
   // Check the header.
   ResourceMetadataHeader header;
   if (!it->Valid() ||
       it->key() != GetHeaderDBKey() ||  // Header entry must come first.
       !header.ParseFromArray(it->value().data(), it->value().size()) ||
       header.version() != kDBVersion) {
     DLOG(ERROR) << "Invalid header detected. version = " << header.version();
+    UMA_HISTOGRAM_ENUMERATION("Drive.MetadataDBValidityCheckFailureReason",

[Alexei Svitkine (slow), 2014/08/05 13:18:16]

Nit: Each histogram macro adds a lot of machine code at the callsite. Can you
instead add a helper function that records the macro and takes the enum value to
record and then call it from every place you record this histogram? This will
avoid bloating the binary.

[hashimoto, 2014/08/06 03:52:20]

Done.

+                              CHECK_VALIDITY_FAILURE_INVALID_HEADER,
+                              CHECK_VALIDITY_FAILURE_MAX_VALUE);
     return false;
   }
 
   // Check all entries.
   size_t num_entries_with_parent = 0;
   size_t num_child_entries = 0;
   ResourceEntry entry;
   std::string serialized_entry;
   std::string child_id;
   for (it->Next(); it->Valid(); it->Next()) {
@@ skipping 10 matching lines @@
       // Resource-ID-to-local-ID mapping without entry for the local ID is ok.
       if (status.IsNotFound())
         continue;
       // When the entry exists, its resource ID must be consistent.
       const bool ok = status.ok() &&
           entry.ParseFromString(serialized_entry) &&
           !entry.resource_id().empty() &&
           leveldb::Slice(GetIdEntryKey(entry.resource_id())) == it->key();
       if (!ok) {
         DLOG(ERROR) << "Broken ID entry. status = " << status.ToString();
+        UMA_HISTOGRAM_ENUMERATION("Drive.MetadataDBValidityCheckFailureReason",
+                                  CHECK_VALIDITY_FAILURE_BROKEN_ID_ENTRY,
+                                  CHECK_VALIDITY_FAILURE_MAX_VALUE);
         return false;
       }
       continue;
     }
 
     // Check if stored data is broken.
     if (!entry.ParseFromArray(it->value().data(), it->value().size())) {
       DLOG(ERROR) << "Broken entry detected";
+      UMA_HISTOGRAM_ENUMERATION("Drive.MetadataDBValidityCheckFailureReason",
+                                CHECK_VALIDITY_FAILURE_BROKEN_ENTRY,
+                                CHECK_VALIDITY_FAILURE_MAX_VALUE);
       return false;
     }
 
     if (leveldb::Slice(entry.local_id()) != it->key()) {
       DLOG(ERROR) << "Wrong local ID.";
+      UMA_HISTOGRAM_ENUMERATION("Drive.MetadataDBValidityCheckFailureReason",
+                                CHECK_VALIDITY_FAILURE_INVALID_LOCAL_ID,
+                                CHECK_VALIDITY_FAILURE_MAX_VALUE);
       return false;
     }
 
     if (!entry.parent_local_id().empty()) {
       // Check if the parent entry is stored.
       leveldb::Status status = resource_map_->Get(
           options,
           leveldb::Slice(entry.parent_local_id()),
           &serialized_entry);
       if (!status.ok()) {
         DLOG(ERROR) << "Can't get parent entry. status = " << status.ToString();
+        UMA_HISTOGRAM_ENUMERATION("Drive.MetadataDBValidityCheckFailureReason",
+                                  CHECK_VALIDITY_FAILURE_INVALID_PARENT_ID,
+                                  CHECK_VALIDITY_FAILURE_MAX_VALUE);
         return false;
       }
 
       // Check if parent-child relationship is stored correctly.
       status = resource_map_->Get(
           options,
           leveldb::Slice(GetChildEntryKey(entry.parent_local_id(),
                                           entry.base_name())),
           &child_id);
       if (!status.ok() || leveldb::Slice(child_id) != it->key()) {
         DLOG(ERROR) << "Child map is broken. status = " << status.ToString();
+        UMA_HISTOGRAM_ENUMERATION("Drive.MetadataDBValidityCheckFailureReason",
+                                  CHECK_VALIDITY_FAILURE_BROKEN_CHILD_MAP,
+                                  CHECK_VALIDITY_FAILURE_MAX_VALUE);
         return false;
       }
       ++num_entries_with_parent;
     }
   }
-  if (!it->status().ok() || num_child_entries != num_entries_with_parent) {
+  if (!it->status().ok()) {
     DLOG(ERROR) << "Error during checking resource map. status = "
                 << it->status().ToString();
+    UMA_HISTOGRAM_ENUMERATION("Drive.MetadataDBValidityCheckFailureReason",
+                              CHECK_VALIDITY_FAILURE_ITERATOR_ERROR,
+                              CHECK_VALIDITY_FAILURE_MAX_VALUE);
+    return false;
+  }
+  if (num_child_entries != num_entries_with_parent) {
+    DLOG(ERROR) << "Child entry count mismatch";
+    UMA_HISTOGRAM_ENUMERATION("Drive.MetadataDBValidityCheckFailureReason",
+                              CHECK_VALIDITY_FAILURE_CHILD_ENTRY_COUNT_MISMATCH,
+                              CHECK_VALIDITY_FAILURE_MAX_VALUE);
     return false;
   }
   return true;
 }
 
 }  // namespace internal
 }  // namespace drive