Add fmtlib for phosphor-debug-collector

Call fmtlib to get additional information from journal.

Tested: built phosphor-debug-collector successfully
        and Unit Test passes.

Signed-off-by: George Liu <liuxiwei@inspur.com>
Change-Id: Ibe65637a0b29b76269fb4bc3f498438901c9306a
diff --git a/dump_offload.cpp b/dump_offload.cpp
index 374a657..3c4b834 100644
--- a/dump_offload.cpp
+++ b/dump_offload.cpp
@@ -2,6 +2,7 @@
 
 #include "dump_offload.hpp"
 
+#include <fmt/core.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/un.h>
@@ -54,8 +55,10 @@
                             NULL, &timeVal);
         if (retVal <= 0)
         {
-            log<level::ERR>("writeOnUnixSocket: select() failed",
-                            entry("ERRNO=%d", errno));
+            log<level::ERR>(
+                fmt::format("writeOnUnixSocket: select() failed, errno({})",
+                            errno)
+                    .c_str());
             std::string msg = "select() failed " + std::string(strerror(errno));
             throw std::runtime_error(msg);
         }
@@ -69,8 +72,10 @@
                     numOfBytesWrote = 0;
                     continue;
                 }
-                log<level::ERR>("writeOnUnixSocket: write() failed",
-                                entry("ERRNO=%d", errno));
+                log<level::ERR>(
+                    fmt::format("writeOnUnixSocket: write() failed, errno({})",
+                                errno)
+                        .c_str());
                 std::string msg =
                     "write() on socket failed " + std::string(strerror(errno));
                 throw std::runtime_error(msg);
@@ -105,23 +110,26 @@
             sizeof(socketAddr.sun_path) - 1);
     if ((unixSocket = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0)) == -1)
     {
-        log<level::ERR>("socketInit: socket() failed",
-                        entry("ERRNO=%d", errno));
+        log<level::ERR>(
+            fmt::format("socketInit: socket() failed, errno({})", errno)
+                .c_str());
         std::string msg = "socket() failed " + std::string(strerror(errno));
         throw std::runtime_error(msg);
     }
     if (bind(unixSocket, (struct sockaddr*)&socketAddr, sizeof(socketAddr)) ==
         -1)
     {
-        log<level::ERR>("socketInit: bind() failed", entry("ERRNO=%d", errno));
+        log<level::ERR>(
+            fmt::format("socketInit: bind() failed, errno({})", errno).c_str());
         close(unixSocket);
         std::string msg = "socket bind failed " + std::string(strerror(errno));
         throw std::runtime_error(msg);
     }
     if (listen(unixSocket, 1) == -1)
     {
-        log<level::ERR>("socketInit: listen() failed",
-                        entry("ERRNO=%d", errno));
+        log<level::ERR>(
+            fmt::format("socketInit: listen() failed, errno({})", errno)
+                .c_str());
         close(unixSocket);
         std::string msg = "listen() failed " + std::string(strerror(errno));
         throw std::runtime_error(msg);
@@ -159,8 +167,10 @@
         int retVal = select(numOfFDs, &readFD, NULL, NULL, &timeVal);
         if (retVal <= 0)
         {
-            log<level::ERR>("select() failed", entry("ERRNO=%d", errno),
-                            entry("DUMP ID=%d", dumpId));
+            log<level::ERR>(
+                fmt::format("select() failed, errno({}), DUMP_ID({})", errno,
+                            dumpId)
+                    .c_str());
             std::string msg = "select() failed " + std::string(strerror(errno));
             throw std::runtime_error(msg);
         }
@@ -169,8 +179,10 @@
             CustomFd socketFD = accept(unixSocket(), NULL, NULL);
             if (socketFD() < 0)
             {
-                log<level::ERR>("accept() failed", entry("ERRNO=%d", errno),
-                                entry("DUMP ID=%d", dumpId));
+                log<level::ERR>(
+                    fmt::format("accept() failed, errno({}), DUMP_ID({})",
+                                errno, dumpId)
+                        .c_str());
                 std::string msg =
                     "accept() failed " + std::string(strerror(errno));
                 throw std::runtime_error(msg);
@@ -180,18 +192,20 @@
             if (!infile.good())
             {
                 // Unable to open the dump file
-                log<level::ERR>("Failed to open the dump from file ",
-                                entry("ERR=%d", errno),
-                                entry("DUMPFILE=%s", dumpPath.c_str()),
-                                entry("DUMP ID=%d", dumpId));
+                log<level::ERR>(
+                    fmt::format("Failed to open the dump from file, errno({}), "
+                                "DUMPFILE({}), DUMP_ID({})",
+                                errno, dumpPath.c_str(), dumpId)
+                        .c_str());
                 elog<Open>(ErrnoOpen(errno), PathOpen(dumpPath.c_str()));
             }
 
             infile.exceptions(std::ifstream::failbit | std::ifstream::badbit |
                               std::ifstream::eofbit);
 
-            log<level::INFO>("Opening File for RW ",
-                             entry("FILENAME=%s", file.filename().c_str()));
+            log<level::INFO>(fmt::format("Opening File for RW, FILENAME({})",
+                                         file.filename().c_str())
+                                 .c_str());
 
             std::filebuf* pbuf = infile.rdbuf();
 
@@ -212,18 +226,21 @@
     {
         std::remove(writePath.c_str());
         auto err = errno;
-        log<level::ERR>("Failed to open", entry("ERR=%s", oe.what()),
-                        entry("OPENINTERFACE=%s", dumpPath.c_str()),
-                        entry("DUMP ID=%d", dumpId));
+        log<level::ERR>(
+            fmt::format(
+                "Failed to open, errormsg({}), OPENINTERFACE({}), DUMP_ID({})",
+                oe.what(), dumpPath.c_str(), dumpId)
+                .c_str());
         elog<Open>(ErrnoOpen(err), PathOpen(dumpPath.c_str()));
     }
     catch (const std::exception& e)
     {
         std::remove(writePath.c_str());
         auto err = errno;
-        log<level::ERR>("Failed to offload dump", entry("ERR=%s", e.what()),
-                        entry("DUMPFILE=%s", writePath.c_str()),
-                        entry("DUMP ID=%d", dumpId));
+        log<level::ERR>(fmt::format("Failed to offload dump, errormsg({}), "
+                                    "DUMPFILE({}), DUMP_ID({})",
+                                    e.what(), writePath.c_str(), dumpId)
+                            .c_str());
         elog<Write>(ErrnoWrite(err), PathWrite(writePath.c_str()));
     }
     std::remove(writePath.c_str());