diff --git a/extensions/openpower-pels/callout.cpp b/extensions/openpower-pels/callout.cpp
index a1d5ebe..f54d77e 100644
--- a/extensions/openpower-pels/callout.cpp
+++ b/extensions/openpower-pels/callout.cpp
@@ -15,9 +15,7 @@
  */
 #include "callout.hpp"
 
-#include "trace.hpp"
-
-#include <fmt/format.h>
+#include <phosphor-logging/log.hpp>
 
 namespace openpower
 {
@@ -26,6 +24,8 @@
 namespace src
 {
 
+using namespace phosphor::logging;
+
 constexpr size_t locationCodeMaxSize = 80;
 
 Callout::Callout(Stream& pel)
@@ -70,8 +70,8 @@
                 break;
             }
             default:
-                trace::error(
-                    fmt::format("Invalid Callout subsection type {}", type));
+                log<level::ERR>("Invalid Callout subsection type",
+                                entry("CALLOUT_TYPE=0x%X", type));
                 throw std::runtime_error("Invalid Callout subsection type");
                 break;
         }
diff --git a/extensions/openpower-pels/callouts.cpp b/extensions/openpower-pels/callouts.cpp
index 0185fc2..7482aca 100644
--- a/extensions/openpower-pels/callouts.cpp
+++ b/extensions/openpower-pels/callouts.cpp
@@ -15,10 +15,9 @@
  */
 #include "callouts.hpp"
 
-#include "trace.hpp"
-
 #include <algorithm>
 #include <map>
+#include <phosphor-logging/log.hpp>
 
 namespace openpower
 {
@@ -61,7 +60,8 @@
     }
     else
     {
-        trace::info("Dropping PEL callout because at max");
+        using namespace phosphor::logging;
+        log<level::INFO>("Dropping PEL callout because at max");
     }
 
     // Mapping including the  3 Medium levels as A,B and C
diff --git a/extensions/openpower-pels/extended_user_data.cpp b/extensions/openpower-pels/extended_user_data.cpp
index cc7d901..6370459 100644
--- a/extensions/openpower-pels/extended_user_data.cpp
+++ b/extensions/openpower-pels/extended_user_data.cpp
@@ -19,13 +19,15 @@
 #ifdef PELTOOL
 #include "user_data_json.hpp"
 #endif
-#include "trace.hpp"
-
 #include <fmt/format.h>
 
+#include <phosphor-logging/log.hpp>
+
 namespace openpower::pels
 {
 
+using namespace phosphor::logging;
+
 void ExtendedUserData::unflatten(Stream& stream)
 {
     stream >> _header;
@@ -58,8 +60,9 @@
     }
     catch (const std::exception& e)
     {
-        trace::error(
-            fmt::format("Cannot unflatten ExtendedUserData: {}", e.what()));
+        log<level::ERR>(
+            fmt::format("Cannot unflatten ExtendedUserData: {}", e.what())
+                .c_str());
         _valid = false;
     }
 }
@@ -85,8 +88,9 @@
 {
     if (header().id != static_cast<uint16_t>(SectionID::extUserData))
     {
-        trace::error(
-            fmt::format("Invalid ExtendedUserData section ID {}", header().id));
+        log<level::ERR>(
+            fmt::format("Invalid ExtendedUserData section ID {}", header().id)
+                .c_str());
         _valid = false;
     }
     else
diff --git a/extensions/openpower-pels/private_header.cpp b/extensions/openpower-pels/private_header.cpp
index 74d895c..31e0f61 100644
--- a/extensions/openpower-pels/private_header.cpp
+++ b/extensions/openpower-pels/private_header.cpp
@@ -19,9 +19,8 @@
 #include "log_id.hpp"
 #include "pel_types.hpp"
 #include "pel_values.hpp"
-#include "trace.hpp"
 
-#include <fmt/format.h>
+#include <phosphor-logging/log.hpp>
 
 namespace openpower
 {
@@ -29,6 +28,7 @@
 {
 
 namespace pv = openpower::pels::pel_values;
+using namespace phosphor::logging;
 
 PrivateHeader::PrivateHeader(uint16_t componentID, uint32_t obmcLogID,
                              uint64_t timestamp)
@@ -77,8 +77,8 @@
     }
     catch (const std::exception& e)
     {
-        trace::error(
-            fmt::format("Cannot unflatten private header: {}", e.what()));
+        log<level::ERR>("Cannot unflatten private header",
+                        entry("ERROR=%s", e.what()));
         _valid = false;
     }
 }
@@ -126,22 +126,22 @@
 
     if (header().id != static_cast<uint16_t>(SectionID::privateHeader))
     {
-        trace::error(fmt::format("Invalid private header section ID: {:#X}",
-                                 header().id));
+        log<level::ERR>("Invalid private header section ID",
+                        entry("ID=0x%X", header().id));
         failed = true;
     }
 
     if (header().version != privateHeaderVersion)
     {
-        trace::error(fmt::format("Invalid private header version: {}",
-                                 header().version));
+        log<level::ERR>("Invalid private header version",
+                        entry("VERSION=0x%X", header().version));
         failed = true;
     }
 
     if (_sectionCount < minSectionCount)
     {
-        trace::error(fmt::format("Invalid section count in private header: {}",
-                                 _sectionCount));
+        log<level::ERR>("Invalid section count in private header",
+                        entry("SECTION_COUNT=0x%X", _sectionCount));
         failed = true;
     }
 
diff --git a/extensions/openpower-pels/tools/peltool.cpp b/extensions/openpower-pels/tools/peltool.cpp
index 98572a8..c1c6da6 100644
--- a/extensions/openpower-pels/tools/peltool.cpp
+++ b/extensions/openpower-pels/tools/peltool.cpp
@@ -21,21 +21,21 @@
 #include "../pel.hpp"
 #include "../pel_types.hpp"
 #include "../pel_values.hpp"
-#include "trace.hpp"
 
 #include <Python.h>
-#include <fmt/format.h>
 
 #include <CLI/CLI.hpp>
 #include <bitset>
 #include <fstream>
 #include <iostream>
+#include <phosphor-logging/log.hpp>
 #include <regex>
 #include <string>
 
 #include "config_main.h"
 
 namespace fs = std::filesystem;
+using namespace phosphor::logging;
 using namespace openpower::pels;
 namespace message = openpower::pels::message;
 namespace pv = openpower::pels::pel_values;
@@ -318,7 +318,8 @@
         std::vector<uint8_t> data = getFileData(fileName);
         if (data.empty())
         {
-            trace::error(fmt::format("Empty PEL file {}", fileName));
+            log<level::ERR>("Empty PEL file",
+                            entry("FILENAME=%s", fileName.c_str()));
             return listStr;
         }
         PEL pel{data};
@@ -441,8 +442,9 @@
     }
     catch (const std::exception& e)
     {
-        trace::error(fmt::format("Hit exception when reading PEL file {}: {}",
-                                 fileName, e.what()));
+        log<level::ERR>("Hit exception while reading PEL File",
+                        entry("FILENAME=%s", fileName.c_str()),
+                        entry("ERROR=%s", e.what()));
     }
     return listStr;
 }
@@ -644,7 +646,7 @@
  */
 void deleteAllPELs()
 {
-    trace::info("peltool deleting all event logs");
+    log<level::INFO>("peltool deleting all event logs");
 
     for (const auto& entry : fs::directory_iterator(pelLogDir()))
     {
diff --git a/extensions/openpower-pels/trace.hpp b/extensions/openpower-pels/trace.hpp
deleted file mode 100644
index 6bf65cf..0000000
--- a/extensions/openpower-pels/trace.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-
-#include <phosphor-logging/log.hpp>
-
-using namespace phosphor::logging;
-
-namespace openpower::pels::trace
-{
-
-inline void info(const std::string& message)
-{
-    log<level::INFO>(message.c_str());
-}
-
-inline void error(const std::string& message)
-{
-    log<level::ERR>(message.c_str());
-}
-
-inline void warning(const std::string& message)
-{
-    log<level::WARNING>(message.c_str());
-}
-
-inline void debug(const std::string& message)
-{
-    log<level::DEBUG>(message.c_str());
-}
-
-} // namespace openpower::pels::trace
diff --git a/extensions/openpower-pels/user_data.cpp b/extensions/openpower-pels/user_data.cpp
index e400e35..e8a72ef 100644
--- a/extensions/openpower-pels/user_data.cpp
+++ b/extensions/openpower-pels/user_data.cpp
@@ -18,19 +18,19 @@
 #include "json_utils.hpp"
 #include "pel_types.hpp"
 #include "user_data_formats.hpp"
-
-#include <fmt/format.h>
 #ifdef PELTOOL
 #include "user_data_json.hpp"
 #endif
 
-#include "trace.hpp"
+#include <phosphor-logging/log.hpp>
 
 namespace openpower
 {
 namespace pels
 {
 
+using namespace phosphor::logging;
+
 void UserData::unflatten(Stream& stream)
 {
     stream >> _header;
@@ -61,7 +61,8 @@
     }
     catch (const std::exception& e)
     {
-        trace::error(fmt::format("Cannot unflatten user data: {}", e.what()));
+        log<level::ERR>("Cannot unflatten user data",
+                        entry("ERROR=%s", e.what()));
         _valid = false;
     }
 }
@@ -84,8 +85,8 @@
 {
     if (header().id != static_cast<uint16_t>(SectionID::userData))
     {
-        trace::error(
-            fmt::format("Invalid user data section ID: {}", header().id));
+        log<level::ERR>("Invalid user data section ID",
+                        entry("ID=0x%X", header().id));
         _valid = false;
     }
     else