Roll errors after reaching Cap size

Fixes openbmc/openbmc#2687

-cap on error exists to deal with small flashes, right now the cap
is 100 for high severity errors and it is 10 for info(and below)
severity) errors.
-previous policy was to stop logging new errors once cap is reached
for high severity errors.
-based on feedback from field engineers, it's better to log new
errors, external tools will typically periodically read and store
errors, so we won't lose them.so the new policy now is to roll errors.

Change-Id: I18b509d81c076fcb80667300cbfda050027bb422
Signed-off-by: Nagaraju Goruganti <ngorugan@in.ibm.com>
diff --git a/log_manager.cpp b/log_manager.cpp
index 0d8e753..cc5e187 100644
--- a/log_manager.cpp
+++ b/log_manager.cpp
@@ -28,7 +28,6 @@
 void Manager::commit(uint64_t transactionId, std::string errMsg)
 {
     auto reqLevel = level::ERR; // Default to ERR
-    size_t realErrCnt = entries.size() - infoErrors.size();
     auto levelmap = g_errLevelMap.find(errMsg);
 
     if (levelmap != g_errLevelMap.end())
@@ -38,17 +37,9 @@
 
     if (static_cast<Entry::Level>(reqLevel) < Entry::sevLowerLimit)
     {
-        if (capped)
+        if (realErrors.size() >= ERROR_CAP)
         {
-            return;
-        }
-        if (realErrCnt >= ERROR_CAP)
-        {
-            log<level::ERR>("Reached error cap, Ignoring error",
-                            entry("SIZE=%d", realErrCnt),
-                            entry("ERROR_CAP=%d", ERROR_CAP));
-            capped = true;
-            return;
+            erase(realErrors.front());
         }
     }
     else
@@ -171,6 +162,10 @@
     {
         infoErrors.push_back(entryId);
     }
+    else
+    {
+        realErrors.push_back(entryId);
+    }
     auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
                 std::chrono::system_clock::now().time_since_epoch()).count();
     auto objPath =  std::string(OBJ_ENTRY) + '/' +
@@ -223,13 +218,22 @@
         fs::path errorPath(ERRLOG_PERSIST_PATH);
         errorPath /= std::to_string(entryId);
         fs::remove(errorPath);
+
+        auto removeId = [](std::list<uint32_t>& ids , uint32_t id)
+        {
+            auto it = std::find(ids.begin(), ids.end(), id);
+            if (it != ids.end())
+            {
+                ids.erase(it);
+            }
+        };
         if (entry->second->severity() >= Entry::sevLowerLimit)
         {
-            auto it = std::find(infoErrors.begin(), infoErrors.end(), entryId);
-            if (it != infoErrors.end())
-            {
-                infoErrors.erase(it);
-            }
+            removeId(infoErrors, entryId);
+        }
+        else
+        {
+            removeId(realErrors, entryId);
         }
         entries.erase(entry);
     }
@@ -238,13 +242,6 @@
         logging::log<level::ERR>("Invalid entry ID to delete",
                 logging::entry("ID=%d", entryId));
     }
-
-    size_t realErrCnt = entries.size() - infoErrors.size();
-
-    if (realErrCnt <  ERROR_CAP)
-    {
-        capped = false;
-    }
 }
 
 void Manager::restore()
@@ -280,6 +277,10 @@
                 {
                     infoErrors.push_back(idNum);
                 }
+                else
+                {
+                    realErrors.push_back(idNum);
+                }
 
                 entries.insert(std::make_pair(idNum, std::move(e)));
                 errorIds.push_back(idNum);