[ugc][statistics] check for zombie reviews

map/framework.cpp

@@ -1440,6 +1440,17 @@ void Framework::InitUGC()
   ASSERT(!m_ugcApi.get(), ("InitUGC() must be called only once."));
 
   m_ugcApi = make_unique<ugc::Api>(m_model.GetDataSource(), [this](size_t numberOfUnsynchronized) {
+
+    bool ugcStorageValidationExecuted = false;
+    if (!settings::Get("WasUgcStorageValidationExecuted", ugcStorageValidationExecuted))
+      ugcStorageValidationExecuted = false;
+
+    if (!ugcStorageValidationExecuted)
+    {
+      m_ugcApi->ValidateStorage();
+      settings::Set("WasUgcStorageValidationExecuted", true);
+    }
+
     if (numberOfUnsynchronized == 0)
       return;
 

ugc/api.cpp

@@ -59,6 +59,11 @@ Loader & Api::GetLoader()
   return m_loader;
 }
 
+void Api::ValidateStorage()
+{
+  m_thread.Push([this] { m_storage.Validate(); });
+}
+
 void Api::GetUGCImpl(FeatureID const & id, UGCCallbackUnsafe const & callback)
 {
   CHECK(callback, ());

ugc/api.hpp

@@ -44,6 +44,8 @@ public:
 
   Loader & GetLoader();
 
+  void ValidateStorage();
+
 private:
   void GetUGCImpl(FeatureID const & id, UGCCallbackUnsafe const & callback);
   Storage::SettingResult SetUGCUpdateImpl(FeatureID const & id, UGCUpdate const & ugc);

ugc/storage.cpp

@@ -19,7 +19,9 @@
 #include "coding/internal/file_data.hpp"
 #include "coding/point_coding.hpp"
 
+#include "base/logging.hpp"
 #include "base/stl_helpers.hpp"
+#include "base/string_utils.hpp"
 
 #include <algorithm>
 #include <map>
@@ -212,6 +214,51 @@ ugc::Storage::SettingResult SetGenericUGCUpdate(UGCUpdate const & ugc,
   return SaveIndexes(indexes) ? ugc::Storage::SettingResult::Success
                               : ugc::Storage::SettingResult::WritingError;
 }
+
+void FindZombieObjects(size_t indexesCount)
+{
+  auto const ugcFilePath = GetUGCFilePath();
+  vector<uint8_t> ugcFileContent;
+  try
+  {
+    FileReader r(ugcFilePath);
+    ugcFileContent = r.ReadAsBytes();
+  }
+  catch (FileReader::Exception const & exception)
+  {
+    ugcFileContent.clear();
+  }
+
+  uint32_t ugcCount = 0;
+
+  MemReaderWithExceptions r(ugcFileContent.data(), ugcFileContent.size());
+  NonOwningReaderSource source(r);
+  ugc::UGCUpdate unused;
+  try
+  {
+    while (source.Size() != 0)
+    {
+      ++ugcCount;
+      ugc::Deserialize(source, unused);
+    }
+  }
+  catch (RootException const & e)
+  {
+    auto const error = "Cannot deserialize ugc.update.bin file during zombie objects search";
+    LOG(LERROR, (error));
+    alohalytics::Stats::Instance().LogEvent("UGC_File_error", {{"error", error}});
+    return;
+  }
+
+  if (indexesCount == ugcCount)
+    return;
+
+  auto const zombieCount = ugcCount - indexesCount;
+  LOG(LERROR, ("Zombie objects are detected. ", zombieCount, "zombie objects are found."));
+
+  alohalytics::Stats::Instance().LogEvent(
+      "UGC_File_error", {{"error", "zombie: " + strings::to_string(zombieCount)}});
+}
 }  // namespace
 
 namespace ugc
@@ -503,6 +550,11 @@ bool Storage::HasUGCForPlace(uint32_t bestType, m2::PointD const & point) const
   return FindIndex(bestType, point) != m_indexes.cend();
 }
 
+void Storage::Validate() const
+{
+  FindZombieObjects(m_indexes.size());
+}
+
 void Storage::MarkAllAsSynchronized()
 {
   if (m_indexes.empty())

ugc/storage.hpp

@@ -41,6 +41,7 @@ public:
   void Load();
   size_t GetNumberOfUnsynchronized() const;
   bool HasUGCForPlace(uint32_t bestType, m2::PointD const & point) const;
+  void Validate() const;
 
   /// Testing
   UpdateIndexes & GetIndexesForTesting() { return m_indexes; }