diff --git a/extensions/openpower-pels/bcd_time.hpp b/extensions/openpower-pels/bcd_time.hpp
index c2f6611..fc1a8bb 100644
--- a/extensions/openpower-pels/bcd_time.hpp
+++ b/extensions/openpower-pels/bcd_time.hpp
@@ -30,9 +30,8 @@
     BCDTime(uint8_t yearMSB, uint8_t yearLSB, uint8_t month, uint8_t day,
             uint8_t hour, uint8_t minutes, uint8_t seconds,
             uint8_t hundredths) :
-        yearMSB(yearMSB),
-        yearLSB(yearLSB), month(month), day(day), hour(hour), minutes(minutes),
-        seconds(seconds), hundredths(hundredths)
+        yearMSB(yearMSB), yearLSB(yearLSB), month(month), day(day), hour(hour),
+        minutes(minutes), seconds(seconds), hundredths(hundredths)
     {}
 
     bool operator==(const BCDTime& right) const;
diff --git a/extensions/openpower-pels/callout.cpp b/extensions/openpower-pels/callout.cpp
index dfc08bd..8cde1c1 100644
--- a/extensions/openpower-pels/callout.cpp
+++ b/extensions/openpower-pels/callout.cpp
@@ -96,8 +96,8 @@
 
     setLocationCode(locationCode);
 
-    _fruIdentity = std::make_unique<FRUIdentity>(partNumber, ccin,
-                                                 serialNumber);
+    _fruIdentity =
+        std::make_unique<FRUIdentity>(partNumber, ccin, serialNumber);
 
     if (!mrus.empty())
     {
@@ -132,8 +132,8 @@
 
     setLocationCode(locationCode);
 
-    _fruIdentity = std::make_unique<FRUIdentity>(symbolicFRU, type,
-                                                 trustedLocationCode);
+    _fruIdentity =
+        std::make_unique<FRUIdentity>(symbolicFRU, type, trustedLocationCode);
 
     _size = flattenedSize();
 }
diff --git a/extensions/openpower-pels/callouts.cpp b/extensions/openpower-pels/callouts.cpp
index 6867798..40b0848 100644
--- a/extensions/openpower-pels/callouts.cpp
+++ b/extensions/openpower-pels/callouts.cpp
@@ -55,8 +55,9 @@
     bool shouldAdd = true;
 
     // Check if there is already a callout for this FRU
-    auto it = std::ranges::find_if(
-        _callouts, [&callout](const auto& c) { return *callout == *c; });
+    auto it = std::ranges::find_if(_callouts, [&callout](const auto& c) {
+        return *callout == *c;
+    });
 
     // If the callout already exists, but the new one has a higher
     // priority, change the existing callout's priority to this
diff --git a/extensions/openpower-pels/data_interface.cpp b/extensions/openpower-pels/data_interface.cpp
index c9a944c..9e2a7e5 100644
--- a/extensions/openpower-pels/data_interface.cpp
+++ b/extensions/openpower-pels/data_interface.cpp
@@ -133,96 +133,96 @@
     _properties.emplace_back(std::make_unique<PropertyWatcher<DataInterface>>(
         bus, object_path::hostState, interface::bootProgress, "BootProgress",
         *this, [this](const auto& value) {
-        this->_bootState = std::get<std::string>(value);
-        auto status = Progress::convertProgressStagesFromString(
-            std::get<std::string>(value));
+            this->_bootState = std::get<std::string>(value);
+            auto status = Progress::convertProgressStagesFromString(
+                std::get<std::string>(value));
 
-        if ((status == Progress::ProgressStages::SystemInitComplete) ||
-            (status == Progress::ProgressStages::OSRunning))
-        {
-            setHostUp(true);
-        }
-        else
-        {
-            setHostUp(false);
-        }
-    }));
+            if ((status == Progress::ProgressStages::SystemInitComplete) ||
+                (status == Progress::ProgressStages::OSRunning))
+            {
+                setHostUp(true);
+            }
+            else
+            {
+                setHostUp(false);
+            }
+        }));
 
     // Watch the host PEL enable property
     _properties.emplace_back(std::make_unique<PropertyWatcher<DataInterface>>(
         bus, object_path::enableHostPELs, interface::enable, "Enabled", *this,
         [this](const auto& value) {
-        if (std::get<bool>(value) != this->_sendPELsToHost)
-        {
-            lg2::info("The send PELs to host setting changed to {VAL}", "VAL",
-                      std::get<bool>(value));
-        }
-        this->_sendPELsToHost = std::get<bool>(value);
-    }));
+            if (std::get<bool>(value) != this->_sendPELsToHost)
+            {
+                lg2::info("The send PELs to host setting changed to {VAL}",
+                          "VAL", std::get<bool>(value));
+            }
+            this->_sendPELsToHost = std::get<bool>(value);
+        }));
 
     // Watch the BMCState property
     _properties.emplace_back(std::make_unique<PropertyWatcher<DataInterface>>(
         bus, object_path::bmcState, interface::bmcState, "CurrentBMCState",
         *this, [this](const auto& value) {
-        const auto& state = std::get<std::string>(value);
-        this->_bmcState = state;
+            const auto& state = std::get<std::string>(value);
+            this->_bmcState = state;
 
-        // Wait for BMC ready to start watching for
-        // plugs so things calm down first.
-        if (BMC::convertBMCStateFromString(state) == BMC::BMCState::Ready)
-        {
-            startFruPlugWatch();
-        }
-    }));
+            // Wait for BMC ready to start watching for
+            // plugs so things calm down first.
+            if (BMC::convertBMCStateFromString(state) == BMC::BMCState::Ready)
+            {
+                startFruPlugWatch();
+            }
+        }));
 
     // Watch the chassis current and requested power state properties
     _properties.emplace_back(std::make_unique<InterfaceWatcher<DataInterface>>(
         bus, object_path::chassisState, interface::chassisState, *this,
         [this](const auto& properties) {
-        auto state = properties.find("CurrentPowerState");
-        if (state != properties.end())
-        {
-            this->_chassisState = std::get<std::string>(state->second);
-        }
+            auto state = properties.find("CurrentPowerState");
+            if (state != properties.end())
+            {
+                this->_chassisState = std::get<std::string>(state->second);
+            }
 
-        auto trans = properties.find("RequestedPowerTransition");
-        if (trans != properties.end())
-        {
-            this->_chassisTransition = std::get<std::string>(trans->second);
-        }
-    }));
+            auto trans = properties.find("RequestedPowerTransition");
+            if (trans != properties.end())
+            {
+                this->_chassisTransition = std::get<std::string>(trans->second);
+            }
+        }));
 
     // Watch the CurrentHostState property
     _properties.emplace_back(std::make_unique<PropertyWatcher<DataInterface>>(
         bus, object_path::hostState, interface::hostState, "CurrentHostState",
         *this, [this](const auto& value) {
-        this->_hostState = std::get<std::string>(value);
-    }));
+            this->_hostState = std::get<std::string>(value);
+        }));
 
     // Watch the BaseBIOSTable property for the hmc managed attribute
     _properties.emplace_back(std::make_unique<PropertyWatcher<DataInterface>>(
         bus, object_path::biosConfigMgr, interface::biosConfigMgr,
         "BaseBIOSTable", service_name::biosConfigMgr, *this,
         [this](const auto& value) {
-        const auto& attributes = std::get<BiosAttributes>(value);
+            const auto& attributes = std::get<BiosAttributes>(value);
 
-        auto it = attributes.find("pvm_hmc_managed");
-        if (it != attributes.end())
-        {
-            const auto& currentValVariant = std::get<5>(it->second);
-            auto currentVal = std::get_if<std::string>(&currentValVariant);
-            if (currentVal)
+            auto it = attributes.find("pvm_hmc_managed");
+            if (it != attributes.end())
             {
-                this->_hmcManaged = (*currentVal == "Enabled") ? true : false;
+                const auto& currentValVariant = std::get<5>(it->second);
+                auto currentVal = std::get_if<std::string>(&currentValVariant);
+                if (currentVal)
+                {
+                    this->_hmcManaged =
+                        (*currentVal == "Enabled") ? true : false;
+                }
             }
-        }
-    }));
+        }));
 }
 
-DBusPropertyMap
-    DataInterface::getAllProperties(const std::string& service,
-                                    const std::string& objectPath,
-                                    const std::string& interface) const
+DBusPropertyMap DataInterface::getAllProperties(
+    const std::string& service, const std::string& objectPath,
+    const std::string& interface) const
 {
     DBusPropertyMap properties;
 
@@ -236,11 +236,10 @@
     return properties;
 }
 
-void DataInterface::getProperty(const std::string& service,
-                                const std::string& objectPath,
-                                const std::string& interface,
-                                const std::string& property,
-                                DBusValue& value) const
+void DataInterface::getProperty(
+    const std::string& service, const std::string& objectPath,
+    const std::string& interface, const std::string& property,
+    DBusValue& value) const
 {
     auto method = _bus.new_method_call(service.c_str(), objectPath.c_str(),
                                        interface::dbusProperty, "Get");
@@ -367,8 +366,8 @@
 
     try
     {
-        auto service = getService(object_path::motherBoardInv,
-                                  interface::viniRecordVPD);
+        auto service =
+            getService(object_path::motherBoardInv, interface::viniRecordVPD);
         if (!service.empty())
         {
             DBusValue value;
@@ -395,8 +394,8 @@
 
     try
     {
-        auto service = getService(object_path::motherBoardInv,
-                                  interface::vsbpRecordVPD);
+        auto service =
+            getService(object_path::motherBoardInv, interface::vsbpRecordVPD);
         if (!service.empty())
         {
             DBusValue value;
@@ -416,10 +415,9 @@
     return systemIM;
 }
 
-void DataInterface::getHWCalloutFields(const std::string& inventoryPath,
-                                       std::string& fruPartNumber,
-                                       std::string& ccin,
-                                       std::string& serialNumber) const
+void DataInterface::getHWCalloutFields(
+    const std::string& inventoryPath, std::string& fruPartNumber,
+    std::string& ccin, std::string& serialNumber) const
 {
     // For now, attempt to get all of the properties directly on the path
     // passed in.  In the future, may need to make use of an algorithm
@@ -430,8 +428,8 @@
 
     auto service = getService(inventoryPath, interface::viniRecordVPD);
 
-    auto properties = getAllProperties(service, inventoryPath,
-                                       interface::viniRecordVPD);
+    auto properties =
+        getAllProperties(service, inventoryPath, interface::viniRecordVPD);
 
     auto value = std::get<std::vector<uint8_t>>(properties["FN"]);
     fruPartNumber = std::string{value.begin(), value.end()};
@@ -498,9 +496,8 @@
     return expandedLocationCode;
 }
 
-std::vector<std::string>
-    DataInterface::getInventoryFromLocCode(const std::string& locationCode,
-                                           uint16_t node, bool expanded) const
+std::vector<std::string> DataInterface::getInventoryFromLocCode(
+    const std::string& locationCode, uint16_t node, bool expanded) const
 {
     std::string methodName = expanded ? "GetFRUsByExpandedLocationCode"
                                       : "GetFRUsByUnexpandedLocationCode";
@@ -542,9 +539,9 @@
                                    bool value) const
 {
     DBusValue variant = value;
-    auto method = _bus.new_method_call(service_name::ledGroupManager,
-                                       ledGroup.c_str(),
-                                       interface::dbusProperty, "Set");
+    auto method =
+        _bus.new_method_call(service_name::ledGroupManager, ledGroup.c_str(),
+                             interface::dbusProperty, "Set");
     method.append(interface::ledGroup, "Asserted", variant);
     _bus.call(method, dbusTimeout);
 }
@@ -644,8 +641,8 @@
 
     try
     {
-        auto service = getService(object_path::logSetting,
-                                  interface::logSetting);
+        auto service =
+            getService(object_path::logSetting, interface::logSetting);
         if (!service.empty())
         {
             DBusValue value;
@@ -813,8 +810,8 @@
                 // If the entry isn't resolved
                 if (!status)
                 {
-                    auto assocService = getService(path,
-                                                   interface::association);
+                    auto assocService =
+                        getService(path, interface::association);
                     if (!assocService.empty())
                     {
                         DBusValue endpoints;
@@ -931,9 +928,11 @@
     // Check if any of the new interfaces are for hot pluggable FRUs.
     if (std::find_if(interfaces.begin(), interfaces.end(),
                      [](const auto& interfacePair) {
-        return std::find(hotplugInterfaces.begin(), hotplugInterfaces.end(),
-                         interfacePair.first) != hotplugInterfaces.end();
-    }) == interfaces.end())
+                         return std::find(hotplugInterfaces.begin(),
+                                          hotplugInterfaces.end(),
+                                          interfacePair.first) !=
+                                hotplugInterfaces.end();
+                     }) == interfaces.end())
     {
         return;
     }
diff --git a/extensions/openpower-pels/data_interface.hpp b/extensions/openpower-pels/data_interface.hpp
index cd710ce..a2f55f4 100644
--- a/extensions/openpower-pels/data_interface.hpp
+++ b/extensions/openpower-pels/data_interface.hpp
@@ -201,11 +201,11 @@
         time_t t(seconds);
         tm* p = gmtime(&t);
 
-        std::string uptime = std::to_string(p->tm_year - 70) + "y " +
-                             std::to_string(p->tm_yday) + "d " +
-                             std::to_string(p->tm_hour) + "h " +
-                             std::to_string(p->tm_min) + "m " +
-                             std::to_string(p->tm_sec) + "s";
+        std::string uptime =
+            std::to_string(p->tm_year - 70) + "y " +
+            std::to_string(p->tm_yday) + "d " + std::to_string(p->tm_hour) +
+            "h " + std::to_string(p->tm_min) + "m " +
+            std::to_string(p->tm_sec) + "s";
 
         return uptime;
     }
@@ -332,10 +332,9 @@
      * @param[out] ccin - Filled in with the VINI/CC keyword
      * @param[out] serialNumber - Filled in with the VINI/SN keyword
      */
-    virtual void getHWCalloutFields(const std::string& inventoryPath,
-                                    std::string& fruPartNumber,
-                                    std::string& ccin,
-                                    std::string& serialNumber) const = 0;
+    virtual void getHWCalloutFields(
+        const std::string& inventoryPath, std::string& fruPartNumber,
+        std::string& ccin, std::string& serialNumber) const = 0;
 
     /**
      * @brief Get the location code for an inventory item.
diff --git a/extensions/openpower-pels/dbus_watcher.hpp b/extensions/openpower-pels/dbus_watcher.hpp
index fdf71e0..3917e19 100644
--- a/extensions/openpower-pels/dbus_watcher.hpp
+++ b/extensions/openpower-pels/dbus_watcher.hpp
@@ -100,8 +100,7 @@
                     const std::string& interface,
                     const std::string& propertyName, const std::string& service,
                     const DataIface& dataIface, PropertySetFunc func) :
-        DBusWatcher(path, interface),
-        _name(propertyName), _setFunc(func)
+        DBusWatcher(path, interface), _name(propertyName), _setFunc(func)
     {
         _matches.emplace_back(
             bus, match_rules::propertiesChanged(_path, _interface),
@@ -279,8 +278,7 @@
     InterfaceWatcher(sdbusplus::bus_t& bus, const std::string& path,
                      const std::string& interface, const DataIface& dataIface,
                      InterfaceSetFunc func) :
-        DBusWatcher(path, interface),
-        _setFunc(func)
+        DBusWatcher(path, interface), _setFunc(func)
     {
         _matches.emplace_back(
             bus, match_rules::propertiesChanged(_path, _interface),
@@ -314,8 +312,8 @@
         auto service = dataIface.getService(_path, _interface);
         if (!service.empty())
         {
-            auto properties = dataIface.getAllProperties(service, _path,
-                                                         _interface);
+            auto properties =
+                dataIface.getAllProperties(service, _path, _interface);
 
             _setFunc(properties);
         }
diff --git a/extensions/openpower-pels/device_callouts.cpp b/extensions/openpower-pels/device_callouts.cpp
index b3f3455..fac7cd3 100644
--- a/extensions/openpower-pels/device_callouts.cpp
+++ b/extensions/openpower-pels/device_callouts.cpp
@@ -273,9 +273,8 @@
  *
  * @return std::vector<Callout> - The callouts
  */
-std::vector<device_callouts::Callout>
-    calloutI2C(size_t i2cBus, uint8_t i2cAddress,
-               const nlohmann::json& calloutJSON)
+std::vector<device_callouts::Callout> calloutI2C(
+    size_t i2cBus, uint8_t i2cAddress, const nlohmann::json& calloutJSON)
 {
     auto busString = std::to_string(i2cBus);
     auto addrString = std::to_string(i2cAddress);
@@ -312,9 +311,8 @@
  *
  * @return std::vector<Callout> - The callouts
  */
-std::vector<device_callouts::Callout>
-    calloutI2CUsingPath(const std::string& devPath,
-                        const nlohmann::json& calloutJSON)
+std::vector<device_callouts::Callout> calloutI2CUsingPath(
+    const std::string& devPath, const nlohmann::json& calloutJSON)
 {
     auto [bus, address] = getI2CSearchKeys(devPath);
 
@@ -447,8 +445,8 @@
  *
  * @return std::vector<Callout> - The list of callouts
  */
-std::vector<device_callouts::Callout> findCallouts(const std::string& devPath,
-                                                   const nlohmann::json& json)
+std::vector<device_callouts::Callout>
+    findCallouts(const std::string& devPath, const nlohmann::json& json)
 {
     std::vector<Callout> callouts;
     fs::path path;
@@ -479,8 +477,8 @@
             callouts = calloutFSISPI(path, json);
             break;
         default:
-            std::string msg = "Could not get callout type from device path: " +
-                              path.string();
+            std::string msg =
+                "Could not get callout type from device path: " + path.string();
             throw std::invalid_argument{msg.c_str()};
             break;
     }
diff --git a/extensions/openpower-pels/device_callouts.hpp b/extensions/openpower-pels/device_callouts.hpp
index c09fc32..e9d1197 100644
--- a/extensions/openpower-pels/device_callouts.hpp
+++ b/extensions/openpower-pels/device_callouts.hpp
@@ -99,9 +99,8 @@
  *                             system.
  * @return std::vector<Callout> - The list of callouts
  */
-std::vector<Callout>
-    getCallouts(const std::string& devPath,
-                const std::vector<std::string>& compatibleList);
+std::vector<Callout> getCallouts(
+    const std::string& devPath, const std::vector<std::string>& compatibleList);
 
 /**
  * @brief Looks up the callouts to add to a PEL for when the path
@@ -153,9 +152,8 @@
  *
  * @return std::vector<Callout> - The callouts
  */
-std::vector<device_callouts::Callout>
-    calloutI2C(size_t i2CBus, uint8_t i2cAddress,
-               const nlohmann::json& calloutJSON);
+std::vector<device_callouts::Callout> calloutI2C(
+    size_t i2CBus, uint8_t i2cAddress, const nlohmann::json& calloutJSON);
 
 /**
  * @brief Determines the type of the path (FSI, I2C, etc) based
diff --git a/extensions/openpower-pels/extended_user_data.cpp b/extensions/openpower-pels/extended_user_data.cpp
index 92d1c70..97ba86b 100644
--- a/extensions/openpower-pels/extended_user_data.cpp
+++ b/extensions/openpower-pels/extended_user_data.cpp
@@ -95,10 +95,9 @@
     }
 }
 
-std::optional<std::string>
-    ExtendedUserData::getJSON(uint8_t /*creatorID*/,
-                              const std::vector<std::string>& plugins
-                              [[maybe_unused]]) const
+std::optional<std::string> ExtendedUserData::getJSON(
+    uint8_t /*creatorID*/,
+    const std::vector<std::string>& plugins [[maybe_unused]]) const
 {
     // Use the creator ID value from the section.
 #ifdef PELTOOL
diff --git a/extensions/openpower-pels/fapi_data_process.cpp b/extensions/openpower-pels/fapi_data_process.cpp
index 252068c..a7cd1b4 100644
--- a/extensions/openpower-pels/fapi_data_process.cpp
+++ b/extensions/openpower-pels/fapi_data_process.cpp
@@ -251,9 +251,8 @@
  * @return NULL
  *
  **/
-void processClockInfoErrorHelper(const FFDC& ffdc,
-                                 json& pelJSONFmtCalloutDataList,
-                                 FFDCData& ffdcUserData)
+void processClockInfoErrorHelper(
+    const FFDC& ffdc, json& pelJSONFmtCalloutDataList, FFDCData& ffdcUserData)
 {
     lg2::info("processClockInfoErrorHelper: FFDC Message[{FFDC_MSG}]",
               "FFDC_MSG", ffdc.message);
@@ -267,11 +266,11 @@
              ffdc.hwp_errorinfo.ffdcs_data.cend(),
              [&ffdcUserData](
                  const std::pair<std::string, std::string>& ele) -> void {
-        std::string keyWithPrefix("HWP_FFDC_");
-        keyWithPrefix.append(ele.first);
+                 std::string keyWithPrefix("HWP_FFDC_");
+                 keyWithPrefix.append(ele.first);
 
-        ffdcUserData.emplace_back(keyWithPrefix, ele.second);
-    });
+                 ffdcUserData.emplace_back(keyWithPrefix, ele.second);
+             });
     // get clock position information
     auto clk_pos = 0xFF; // Invalid position.
     for (auto& hwCallout : ffdc.hwp_errorinfo.hwcallouts)
@@ -288,14 +287,15 @@
              ffdc.hwp_errorinfo.cdg_targets.end(),
              [&ffdcUserData, &pelJSONFmtCalloutDataList,
               clk_pos](const CDG_Target& cdg_tgt) -> void {
-        json jsonCalloutData;
-        std::string pelPriority = "H";
-        jsonCalloutData["Priority"] = pelPriority; // Not used
-        jsonCalloutData["SymbolicFRU"] = "REFCLK" + std::to_string(clk_pos);
-        jsonCalloutData["Deconfigured"] = cdg_tgt.deconfigure;
-        jsonCalloutData["EntityPath"] = cdg_tgt.target_entity_path;
-        pelJSONFmtCalloutDataList.emplace_back(jsonCalloutData);
-    });
+                 json jsonCalloutData;
+                 std::string pelPriority = "H";
+                 jsonCalloutData["Priority"] = pelPriority; // Not used
+                 jsonCalloutData["SymbolicFRU"] =
+                     "REFCLK" + std::to_string(clk_pos);
+                 jsonCalloutData["Deconfigured"] = cdg_tgt.deconfigure;
+                 jsonCalloutData["EntityPath"] = cdg_tgt.target_entity_path;
+                 pelJSONFmtCalloutDataList.emplace_back(jsonCalloutData);
+             });
 }
 
 void convertFAPItoPELformat(FFDC& ffdc, json& pelJSONFmtCalloutDataList,
@@ -319,119 +319,126 @@
             ffdc.hwp_errorinfo.ffdcs_data.begin(),
             ffdc.hwp_errorinfo.ffdcs_data.end(),
             [&ffdcUserData](std::pair<std::string, std::string>& ele) -> void {
-            std::string keyWithPrefix("HWP_FFDC_");
-            keyWithPrefix.append(ele.first);
+                std::string keyWithPrefix("HWP_FFDC_");
+                keyWithPrefix.append(ele.first);
 
-            ffdcUserData.emplace_back(keyWithPrefix, ele.second);
-        });
+                ffdcUserData.emplace_back(keyWithPrefix, ele.second);
+            });
 
         // Adding hardware callout details
         int calloutCount = 0;
-        for_each(ffdc.hwp_errorinfo.hwcallouts.begin(),
-                 ffdc.hwp_errorinfo.hwcallouts.end(),
-                 [&ffdcUserData, &calloutCount, &pelJSONFmtCalloutDataList](
-                     const HWCallout& hwCallout) -> void {
-            calloutCount++;
-            std::stringstream keyPrefix;
-            keyPrefix << "HWP_HW_CO_" << std::setfill('0') << std::setw(2)
-                      << calloutCount << "_";
+        for_each(
+            ffdc.hwp_errorinfo.hwcallouts.begin(),
+            ffdc.hwp_errorinfo.hwcallouts.end(),
+            [&ffdcUserData, &calloutCount,
+             &pelJSONFmtCalloutDataList](const HWCallout& hwCallout) -> void {
+                calloutCount++;
+                std::stringstream keyPrefix;
+                keyPrefix << "HWP_HW_CO_" << std::setfill('0') << std::setw(2)
+                          << calloutCount << "_";
 
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("HW_ID"), hwCallout.hwid);
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("HW_ID"),
+                    hwCallout.hwid);
 
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("PRIORITY"),
-                hwCallout.callout_priority);
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("PRIORITY"),
+                    hwCallout.callout_priority);
 
-            phal::TargetInfo targetInfo;
-            phal::getTgtReqAttrsVal(hwCallout.target_entity_path, targetInfo);
+                phal::TargetInfo targetInfo;
+                phal::getTgtReqAttrsVal(hwCallout.target_entity_path,
+                                        targetInfo);
 
-            std::string locationCode = std::string(targetInfo.locationCode);
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("LOC_CODE"), locationCode);
+                std::string locationCode = std::string(targetInfo.locationCode);
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("LOC_CODE"),
+                    locationCode);
 
-            std::string physPath = std::string(targetInfo.physDevPath);
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("PHYS_PATH"), physPath);
+                std::string physPath = std::string(targetInfo.physDevPath);
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("PHYS_PATH"), physPath);
 
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("CLK_POS"),
-                std::to_string(hwCallout.clkPos));
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("CLK_POS"),
+                    std::to_string(hwCallout.clkPos));
 
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("CALLOUT_PLANAR"),
-                (hwCallout.isPlanarCallout == true ? "true" : "false"));
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("CALLOUT_PLANAR"),
+                    (hwCallout.isPlanarCallout == true ? "true" : "false"));
 
-            std::string pelPriority =
-                getPelPriority(hwCallout.callout_priority);
+                std::string pelPriority =
+                    getPelPriority(hwCallout.callout_priority);
 
-            if (hwCallout.isPlanarCallout)
-            {
-                addPlanarCallout(pelJSONFmtCalloutDataList, pelPriority);
-            }
-        });
+                if (hwCallout.isPlanarCallout)
+                {
+                    addPlanarCallout(pelJSONFmtCalloutDataList, pelPriority);
+                }
+            });
 
         // Adding CDG (callout, deconfigure and guard) targets details
         calloutCount = 0;
-        for_each(ffdc.hwp_errorinfo.cdg_targets.begin(),
-                 ffdc.hwp_errorinfo.cdg_targets.end(),
-                 [&ffdcUserData, &calloutCount, &pelJSONFmtCalloutDataList](
-                     const CDG_Target& cdg_tgt) -> void {
-            calloutCount++;
-            std::stringstream keyPrefix;
-            keyPrefix << "HWP_CDG_TGT_" << std::setfill('0') << std::setw(2)
-                      << calloutCount << "_";
+        for_each(
+            ffdc.hwp_errorinfo.cdg_targets.begin(),
+            ffdc.hwp_errorinfo.cdg_targets.end(),
+            [&ffdcUserData, &calloutCount,
+             &pelJSONFmtCalloutDataList](const CDG_Target& cdg_tgt) -> void {
+                calloutCount++;
+                std::stringstream keyPrefix;
+                keyPrefix << "HWP_CDG_TGT_" << std::setfill('0') << std::setw(2)
+                          << calloutCount << "_";
 
-            phal::TargetInfo targetInfo;
-            targetInfo.deconfigure = cdg_tgt.deconfigure;
+                phal::TargetInfo targetInfo;
+                targetInfo.deconfigure = cdg_tgt.deconfigure;
 
-            phal::getTgtReqAttrsVal(cdg_tgt.target_entity_path, targetInfo);
+                phal::getTgtReqAttrsVal(cdg_tgt.target_entity_path, targetInfo);
 
-            std::string locationCode = std::string(targetInfo.locationCode);
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("LOC_CODE"), locationCode);
-            std::string physPath = std::string(targetInfo.physDevPath);
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("PHYS_PATH"), physPath);
+                std::string locationCode = std::string(targetInfo.locationCode);
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("LOC_CODE"),
+                    locationCode);
+                std::string physPath = std::string(targetInfo.physDevPath);
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("PHYS_PATH"), physPath);
 
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("CO_REQ"),
-                (cdg_tgt.callout == true ? "true" : "false"));
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("CO_REQ"),
+                    (cdg_tgt.callout == true ? "true" : "false"));
 
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("CO_PRIORITY"),
-                cdg_tgt.callout_priority);
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("CO_PRIORITY"),
+                    cdg_tgt.callout_priority);
 
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("DECONF_REQ"),
-                (cdg_tgt.deconfigure == true ? "true" : "false"));
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("DECONF_REQ"),
+                    (cdg_tgt.deconfigure == true ? "true" : "false"));
 
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("GUARD_REQ"),
-                (cdg_tgt.guard == true ? "true" : "false"));
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("GUARD_REQ"),
+                    (cdg_tgt.guard == true ? "true" : "false"));
 
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("GUARD_TYPE"),
-                cdg_tgt.guard_type);
+                ffdcUserData.emplace_back(
+                    std::string(keyPrefix.str()).append("GUARD_TYPE"),
+                    cdg_tgt.guard_type);
 
-            json jsonCalloutData;
-            jsonCalloutData["LocationCode"] = locationCode;
-            std::string pelPriority = getPelPriority(cdg_tgt.callout_priority);
-            jsonCalloutData["Priority"] = pelPriority;
+                json jsonCalloutData;
+                jsonCalloutData["LocationCode"] = locationCode;
+                std::string pelPriority =
+                    getPelPriority(cdg_tgt.callout_priority);
+                jsonCalloutData["Priority"] = pelPriority;
 
-            if (targetInfo.mruId != 0)
-            {
-                jsonCalloutData["MRUs"] = json::array({
-                    {{"ID", targetInfo.mruId}, {"Priority", pelPriority}},
-                });
-            }
-            jsonCalloutData["Deconfigured"] = cdg_tgt.deconfigure;
-            jsonCalloutData["Guarded"] = cdg_tgt.guard;
-            jsonCalloutData["GuardType"] = cdg_tgt.guard_type;
-            jsonCalloutData["EntityPath"] = cdg_tgt.target_entity_path;
+                if (targetInfo.mruId != 0)
+                {
+                    jsonCalloutData["MRUs"] = json::array({
+                        {{"ID", targetInfo.mruId}, {"Priority", pelPriority}},
+                    });
+                }
+                jsonCalloutData["Deconfigured"] = cdg_tgt.deconfigure;
+                jsonCalloutData["Guarded"] = cdg_tgt.guard;
+                jsonCalloutData["GuardType"] = cdg_tgt.guard_type;
+                jsonCalloutData["EntityPath"] = cdg_tgt.target_entity_path;
 
-            pelJSONFmtCalloutDataList.emplace_back(jsonCalloutData);
-        });
+                pelJSONFmtCalloutDataList.emplace_back(jsonCalloutData);
+            });
 
         // Adding procedure callout
         calloutCount = 0;
@@ -439,23 +446,23 @@
                  ffdc.hwp_errorinfo.procedures_callout.end(),
                  [&ffdcUserData, &calloutCount, &pelJSONFmtCalloutDataList](
                      const ProcedureCallout& procCallout) -> void {
-            calloutCount++;
-            std::stringstream keyPrefix;
-            keyPrefix << "HWP_PROC_CO_" << std::setfill('0') << std::setw(2)
-                      << calloutCount << "_";
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("PRIORITY"),
-                procCallout.callout_priority);
-            ffdcUserData.emplace_back(
-                std::string(keyPrefix.str()).append("MAINT_PROCEDURE"),
-                procCallout.proc_callout);
-            json jsonCalloutData;
-            jsonCalloutData["Procedure"] = procCallout.proc_callout;
-            std::string pelPriority =
-                getPelPriority(procCallout.callout_priority);
-            jsonCalloutData["Priority"] = pelPriority;
-            pelJSONFmtCalloutDataList.emplace_back(jsonCalloutData);
-        });
+                     calloutCount++;
+                     std::stringstream keyPrefix;
+                     keyPrefix << "HWP_PROC_CO_" << std::setfill('0')
+                               << std::setw(2) << calloutCount << "_";
+                     ffdcUserData.emplace_back(
+                         std::string(keyPrefix.str()).append("PRIORITY"),
+                         procCallout.callout_priority);
+                     ffdcUserData.emplace_back(
+                         std::string(keyPrefix.str()).append("MAINT_PROCEDURE"),
+                         procCallout.proc_callout);
+                     json jsonCalloutData;
+                     jsonCalloutData["Procedure"] = procCallout.proc_callout;
+                     std::string pelPriority =
+                         getPelPriority(procCallout.callout_priority);
+                     jsonCalloutData["Priority"] = pelPriority;
+                     pelJSONFmtCalloutDataList.emplace_back(jsonCalloutData);
+                 });
     }
     else if ((ffdc.ffdc_type != FFDC_TYPE_NONE) &&
              (ffdc.ffdc_type != FFDC_TYPE_UNSUPPORTED))
diff --git a/extensions/openpower-pels/host_notifier.cpp b/extensions/openpower-pels/host_notifier.cpp
index a4ea9d5..fee1d56 100644
--- a/extensions/openpower-pels/host_notifier.cpp
+++ b/extensions/openpower-pels/host_notifier.cpp
@@ -25,16 +25,15 @@
 
 HostNotifier::HostNotifier(Repository& repo, DataInterfaceBase& dataIface,
                            std::unique_ptr<HostInterface> hostIface) :
-    _repo(repo),
-    _dataIface(dataIface), _hostIface(std::move(hostIface)),
+    _repo(repo), _dataIface(dataIface), _hostIface(std::move(hostIface)),
     _retryTimer(_hostIface->getEvent(),
                 std::bind(std::mem_fn(&HostNotifier::retryTimerExpired), this)),
     _hostFullTimer(
         _hostIface->getEvent(),
         std::bind(std::mem_fn(&HostNotifier::hostFullTimerExpired), this)),
-    _hostUpTimer(
-        _hostIface->getEvent(),
-        std::bind(std::mem_fn(&HostNotifier::hostUpTimerExpired), this))
+    _hostUpTimer(_hostIface->getEvent(),
+                 std::bind(std::mem_fn(&HostNotifier::hostUpTimerExpired),
+                           this))
 {
     // Subscribe to be told about new PELs.
     _repo.subscribeToAdds(subscriptionName,
diff --git a/extensions/openpower-pels/journal.cpp b/extensions/openpower-pels/journal.cpp
index 5a4238f..8b7f1f7 100644
--- a/extensions/openpower-pels/journal.cpp
+++ b/extensions/openpower-pels/journal.cpp
@@ -68,8 +68,8 @@
     }
 }
 
-std::vector<std::string> Journal::getMessages(const std::string& syslogID,
-                                              size_t maxMessages) const
+std::vector<std::string>
+    Journal::getMessages(const std::string& syslogID, size_t maxMessages) const
 {
     // The message registry JSON schema will also fail if a zero is in the JSON
     if (0 == maxMessages)
@@ -83,8 +83,8 @@
     int rc = sd_journal_open(&journal, SD_JOURNAL_LOCAL_ONLY);
     if (rc < 0)
     {
-        throw std::runtime_error{std::string{"Failed to open journal: "} +
-                                 strerror(-rc)};
+        throw std::runtime_error{
+            std::string{"Failed to open journal: "} + strerror(-rc)};
     }
 
     JournalCloser closer{journal};
diff --git a/extensions/openpower-pels/journal.hpp b/extensions/openpower-pels/journal.hpp
index 620ce50..8873ff5 100644
--- a/extensions/openpower-pels/journal.hpp
+++ b/extensions/openpower-pels/journal.hpp
@@ -30,8 +30,8 @@
      *
      * @return The messages
      */
-    virtual std::vector<std::string> getMessages(const std::string& syslogID,
-                                                 size_t maxMessages) const = 0;
+    virtual std::vector<std::string>
+        getMessages(const std::string& syslogID, size_t maxMessages) const = 0;
 
     /**
      * @brief Call journalctl --sync to write unwritten journal data to disk
diff --git a/extensions/openpower-pels/json_utils.cpp b/extensions/openpower-pels/json_utils.cpp
index fa3246e..ce2a27d 100644
--- a/extensions/openpower-pels/json_utils.cpp
+++ b/extensions/openpower-pels/json_utils.cpp
@@ -176,8 +176,8 @@
 void jsonInsert(std::string& jsonStr, const std::string& fieldName,
                 const std::string& fieldValue, uint8_t indentCount)
 {
-    const int8_t spacesToAppend = colAlign - (indentCount * indentLevel) -
-                                  fieldName.length() - 3;
+    const int8_t spacesToAppend =
+        colAlign - (indentCount * indentLevel) - fieldName.length() - 3;
     const std::string jsonIndent(indentCount * indentLevel, 0x20);
     jsonStr.append(jsonIndent + "\"" + fieldName + "\":");
     if (spacesToAppend >= 0)
@@ -215,8 +215,8 @@
     }
     else
     {
-        const int8_t spacesToAppend = colAlign - (indentCount * indentLevel) -
-                                      fieldName.length() - 3;
+        const int8_t spacesToAppend =
+            colAlign - (indentCount * indentLevel) - fieldName.length() - 3;
         jsonStr.append(jsonIndent + "\"" + fieldName + "\":");
         if (spacesToAppend > 0)
         {
@@ -252,14 +252,14 @@
  * @param[in] creatorID - The creator ID for the PEL
  * @return optional<string> - The comp name, or std::nullopt
  */
-static std::optional<std::string> lookupComponentName(uint16_t compID,
-                                                      char creatorID)
+static std::optional<std::string>
+    lookupComponentName(uint16_t compID, char creatorID)
 {
     static std::map<char, nlohmann::json> jsonCache;
     nlohmann::json jsonData;
     nlohmann::json* jsonPtr = &jsonData;
-    std::filesystem::path filename{std::string{creatorID} +
-                                   "_component_ids.json"};
+    std::filesystem::path filename{
+        std::string{creatorID} + "_component_ids.json"};
     filename = getPELReadOnlyDataPath() / filename;
 
     auto jsonIt = jsonCache.find(creatorID);
diff --git a/extensions/openpower-pels/manager.cpp b/extensions/openpower-pels/manager.cpp
index 0689a8b..a362e01 100644
--- a/extensions/openpower-pels/manager.cpp
+++ b/extensions/openpower-pels/manager.cpp
@@ -338,12 +338,11 @@
     return pelFFDC;
 }
 
-void Manager::createPEL(const std::string& message, uint32_t obmcLogID,
-                        uint64_t timestamp,
-                        phosphor::logging::Entry::Level severity,
-                        const std::vector<std::string>& additionalData,
-                        const std::vector<std::string>& /*associations*/,
-                        const FFDCEntries& ffdc)
+void Manager::createPEL(
+    const std::string& message, uint32_t obmcLogID, uint64_t timestamp,
+    phosphor::logging::Entry::Level severity,
+    const std::vector<std::string>& additionalData,
+    const std::vector<std::string>& /*associations*/, const FFDCEntries& ffdc)
 {
     auto entry = _registry.lookup(message, rg::LookupType::name);
     auto pelFFDC = convertToPelFFDC(ffdc);
@@ -860,8 +859,8 @@
     auto entryN = _logManager.entries.find(pel.obmcLogID());
     if (entryN != _logManager.entries.end())
     {
-        auto newSeverity = fixupLogSeverity(entryN->second->severity(),
-                                            sevType);
+        auto newSeverity =
+            fixupLogSeverity(entryN->second->severity(), sevType);
         if (newSeverity)
         {
             lg2::info("Changing event log {ID} severity from {OLD} "
@@ -1001,8 +1000,8 @@
             // Read bytes from offset [40-47] e.g. BD8D1001
             for (int i = 0; i < 8; i++)
             {
-                srcRefCode |= (static_cast<uint64_t>(asciiSRC[40 + i])
-                               << (8 * i));
+                srcRefCode |=
+                    (static_cast<uint64_t>(asciiSRC[40 + i]) << (8 * i));
             }
 
             try
@@ -1084,8 +1083,8 @@
 {
     Repository::PELUpdateFunc handlePowerThermalHardwarePresent =
         [locationCode](openpower::pels::PEL& pel) {
-        return Manager::clearPowerThermalDeconfigFlag(locationCode, pel);
-    };
+            return Manager::clearPowerThermalDeconfigFlag(locationCode, pel);
+        };
 
     // If the PEL was created by the BMC and has the deconfig flag set,
     // it's a candidate to have the deconfig flag cleared.
diff --git a/extensions/openpower-pels/manager.hpp b/extensions/openpower-pels/manager.hpp
index c5bda7f..462949d 100644
--- a/extensions/openpower-pels/manager.hpp
+++ b/extensions/openpower-pels/manager.hpp
@@ -51,9 +51,8 @@
             std::unique_ptr<DataInterfaceBase> dataIface,
             EventLogger::LogFunction creatorFunc,
             std::unique_ptr<JournalBase> journal) :
-        PELInterface(logManager.getBus(), OBJ_LOGGING),
-        _logManager(logManager), _eventLogger(std::move(creatorFunc)),
-        _repo(getPELRepoPath()),
+        PELInterface(logManager.getBus(), OBJ_LOGGING), _logManager(logManager),
+        _eventLogger(std::move(creatorFunc)), _repo(getPELRepoPath()),
         _registry(getPELReadOnlyDataPath() / message::registryFileName),
         _event(sdeventplus::Event::get_default()),
         _dataIface(std::move(dataIface)), _journal(std::move(journal))
diff --git a/extensions/openpower-pels/mru.cpp b/extensions/openpower-pels/mru.cpp
index e53966a..cfc6cdb 100644
--- a/extensions/openpower-pels/mru.cpp
+++ b/extensions/openpower-pels/mru.cpp
@@ -41,9 +41,9 @@
         _mrus.push_back(std::move(mru));
     }
 
-    size_t actualSize = sizeof(_type) + sizeof(_size) + sizeof(_flags) +
-                        sizeof(_reserved4B) +
-                        (sizeof(MRUCallout) * _mrus.size());
+    size_t actualSize =
+        sizeof(_type) + sizeof(_size) + sizeof(_flags) + sizeof(_reserved4B) +
+        (sizeof(MRUCallout) * _mrus.size());
     if (_size != actualSize)
     {
         lg2::warning(
diff --git a/extensions/openpower-pels/pel.cpp b/extensions/openpower-pels/pel.cpp
index 64244c3..ee8ebf6 100644
--- a/extensions/openpower-pels/pel.cpp
+++ b/extensions/openpower-pels/pel.cpp
@@ -63,18 +63,18 @@
 #ifdef PEL_ENABLE_PHAL
     // Add sbe ffdc processed data into ffdcfiles.
     namespace sbe = openpower::pels::sbe;
-    auto processReq = std::any_of(ffdcFiles.begin(), ffdcFiles.end(),
-                                  [](const auto& file) {
-        return file.format == UserDataFormat::custom &&
-               file.subType == sbe::sbeFFDCSubType;
-    });
+    auto processReq =
+        std::any_of(ffdcFiles.begin(), ffdcFiles.end(), [](const auto& file) {
+            return file.format == UserDataFormat::custom &&
+                   file.subType == sbe::sbeFFDCSubType;
+        });
     // sbeFFDC can't be destroyed until the end of the PEL constructor
     // because it needs to keep around the FFDC Files to be used below.
     std::unique_ptr<sbe::SbeFFDC> sbeFFDCPtr;
     if (processReq)
     {
-        sbeFFDCPtr = std::make_unique<sbe::SbeFFDC>(additionalData,
-                                                    ffdcFilesIn);
+        sbeFFDCPtr =
+            std::make_unique<sbe::SbeFFDC>(additionalData, ffdcFilesIn);
         const auto& sbeFFDCFiles = sbeFFDCPtr->getSbeFFDC();
         ffdcFiles.insert(ffdcFiles.end(), sbeFFDCFiles.begin(),
                          sbeFFDCFiles.end());
@@ -109,8 +109,8 @@
         }
     }
 
-    auto src = std::make_unique<SRC>(regEntry, additionalData, callouts,
-                                     dataIface);
+    auto src =
+        std::make_unique<SRC>(regEntry, additionalData, callouts, dataIface);
 
     if (!src->getDebugData().empty())
     {
@@ -307,11 +307,11 @@
 
 std::optional<SRC*> PEL::primarySRC() const
 {
-    auto src = std::find_if(_optionalSections.begin(), _optionalSections.end(),
-                            [](auto& section) {
-        return section->header().id ==
-               static_cast<uint16_t>(SectionID::primarySRC);
-    });
+    auto src = std::find_if(
+        _optionalSections.begin(), _optionalSections.end(), [](auto& section) {
+            return section->header().id ==
+                   static_cast<uint16_t>(SectionID::primarySRC);
+        });
     if (src != _optionalSections.end())
     {
         return static_cast<SRC*>(src->get());
@@ -327,19 +327,18 @@
     // assume the user knows what they are doing.
     if (_uh->actionFlags() == actionFlagsDefault)
     {
-        auto [actionFlags, eventType] = pel_rules::check(0, _uh->eventType(),
-                                                         _uh->severity());
+        auto [actionFlags, eventType] =
+            pel_rules::check(0, _uh->eventType(), _uh->severity());
 
         _uh->setActionFlags(actionFlags);
         _uh->setEventType(eventType);
     }
 }
 
-void PEL::printSectionInJSON(const Section& section, std::string& buf,
-                             std::map<uint16_t, size_t>& pluralSections,
-                             message::Registry& registry,
-                             const std::vector<std::string>& plugins,
-                             uint8_t creatorID) const
+void PEL::printSectionInJSON(
+    const Section& section, std::string& buf,
+    std::map<uint16_t, size_t>& pluralSections, message::Registry& registry,
+    const std::vector<std::string>& plugins, uint8_t creatorID) const
 {
     char tmpB[5];
     uint8_t id[] = {static_cast<uint8_t>(section.header().id >> 8),
@@ -553,11 +552,12 @@
     if (_ph->creatorID() == static_cast<uint8_t>(CreatorID::hostboot))
     {
         // Get the ED section from PEL
-        auto op = std::find_if(_optionalSections.begin(),
-                               _optionalSections.end(), [](auto& section) {
-            return section->header().id ==
-                   static_cast<uint16_t>(SectionID::extUserData);
-        });
+        auto op = std::find_if(
+            _optionalSections.begin(), _optionalSections.end(),
+            [](auto& section) {
+                return section->header().id ==
+                       static_cast<uint16_t>(SectionID::extUserData);
+            });
 
         // Check for ED section found and its not the last section of PEL
         if (op != _optionalSections.end())
@@ -846,10 +846,9 @@
     json["BMCLoad"] = dataIface.getBMCLoadAvg();
 }
 
-std::unique_ptr<UserData>
-    makeSysInfoUserDataSection(const AdditionalData& ad,
-                               const DataInterfaceBase& dataIface,
-                               bool addUptime)
+std::unique_ptr<UserData> makeSysInfoUserDataSection(
+    const AdditionalData& ad, const DataInterfaceBase& dataIface,
+    bool addUptime)
 {
     nlohmann::json json;
 
@@ -916,8 +915,8 @@
     return data;
 }
 
-std::unique_ptr<UserData> makeFFDCuserDataSection(uint16_t componentID,
-                                                  const PelFFDCfile& file)
+std::unique_ptr<UserData>
+    makeFFDCuserDataSection(uint16_t componentID, const PelFFDCfile& file)
 {
     auto data = readFD(file.fd);
 
diff --git a/extensions/openpower-pels/pel.hpp b/extensions/openpower-pels/pel.hpp
index f6ff165..8abefa4 100644
--- a/extensions/openpower-pels/pel.hpp
+++ b/extensions/openpower-pels/pel.hpp
@@ -382,11 +382,10 @@
      * @param[in] plugins - Vector of strings of plugins found in filesystem
      * @param[in] creatorID - Creator Subsystem ID (only for UserData section)
      */
-    void printSectionInJSON(const Section& section, std::string& buf,
-                            std::map<uint16_t, size_t>& pluralSections,
-                            message::Registry& registry,
-                            const std::vector<std::string>& plugins,
-                            uint8_t creatorID = 0) const;
+    void printSectionInJSON(
+        const Section& section, std::string& buf,
+        std::map<uint16_t, size_t>& pluralSections, message::Registry& registry,
+        const std::vector<std::string>& plugins, uint8_t creatorID = 0) const;
 
     /**
      * @brief Returns any callout JSON found in the FFDC files.
@@ -470,10 +469,9 @@
  *
  * @return std::unique_ptr<UserData> - The section
  */
-std::unique_ptr<UserData>
-    makeSysInfoUserDataSection(const AdditionalData& ad,
-                               const DataInterfaceBase& dataIface,
-                               bool addUptime = true);
+std::unique_ptr<UserData> makeSysInfoUserDataSection(
+    const AdditionalData& ad, const DataInterfaceBase& dataIface,
+    bool addUptime = true);
 
 /**
  * @brief Reads data from an opened file descriptor.
@@ -491,8 +489,8 @@
  * @param[in] componentID - The component ID of the PEL creator
  * @param[in] file - The FFDC file information
  */
-std::unique_ptr<UserData> makeFFDCuserDataSection(uint16_t componentID,
-                                                  const PelFFDCfile& file);
+std::unique_ptr<UserData>
+    makeFFDCuserDataSection(uint16_t componentID, const PelFFDCfile& file);
 
 /**
  * @brief Flattens a vector of strings into a vector of bytes suitable
diff --git a/extensions/openpower-pels/pel_entry.hpp b/extensions/openpower-pels/pel_entry.hpp
index 482efce..48d43eb 100644
--- a/extensions/openpower-pels/pel_entry.hpp
+++ b/extensions/openpower-pels/pel_entry.hpp
@@ -32,8 +32,7 @@
     PELEntry(sdbusplus::bus_t& bus, const std::string& path,
              const std::map<std::string, PropertiesVariant>& prop, uint32_t id,
              Repository* repo) :
-        PELEntryIface(bus, path.c_str(), prop, true),
-        _obmcId(id), _repo(repo)
+        PELEntryIface(bus, path.c_str(), prop, true), _obmcId(id), _repo(repo)
     {}
 
     /** @brief Update managementSystemAck flag.
diff --git a/extensions/openpower-pels/pel_values.cpp b/extensions/openpower-pels/pel_values.cpp
index e52f7e1..a94606c 100644
--- a/extensions/openpower-pels/pel_values.cpp
+++ b/extensions/openpower-pels/pel_values.cpp
@@ -252,8 +252,8 @@
 {
     return std::find_if(fields.begin(), fields.end(),
                         [value](const auto& entry) {
-        return value == std::get<fieldValuePos>(entry);
-    });
+                            return value == std::get<fieldValuePos>(entry);
+                        });
 }
 
 PELValues::const_iterator findByName(const std::string& name,
@@ -262,8 +262,8 @@
 {
     return std::find_if(fields.begin(), fields.end(),
                         [&name](const auto& entry) {
-        return name == std::get<registryNamePos>(entry);
-    });
+                            return name == std::get<registryNamePos>(entry);
+                        });
 }
 
 /**
@@ -357,13 +357,13 @@
                                           const pel_values::PELValues& table)
 {
     std::vector<std::string> foundValues;
-    std::for_each(table.begin(), table.end(),
-                  [&value, &foundValues](const auto& entry) {
-        if (value & std::get<fieldValuePos>(entry))
-        {
-            foundValues.push_back(std::get<descriptionPos>(entry));
-        }
-    });
+    std::for_each(
+        table.begin(), table.end(), [&value, &foundValues](const auto& entry) {
+            if (value & std::get<fieldValuePos>(entry))
+            {
+                foundValues.push_back(std::get<descriptionPos>(entry));
+            }
+        });
     return foundValues;
 }
 
diff --git a/extensions/openpower-pels/pldm_interface.cpp b/extensions/openpower-pels/pldm_interface.cpp
index 51160f8..392bd00 100644
--- a/extensions/openpower-pels/pldm_interface.cpp
+++ b/extensions/openpower-pels/pldm_interface.cpp
@@ -187,9 +187,9 @@
 
     if (rc == -EINVAL)
     {
-        throw std::runtime_error("Instance ID " + std::to_string(*_instanceID) +
-                                 " for TID " + std::to_string(_eid) +
-                                 " was not previously allocated");
+        throw std::runtime_error(
+            "Instance ID " + std::to_string(*_instanceID) + " for TID " +
+            std::to_string(_eid) + " was not previously allocated");
     }
     else if (rc)
     {
@@ -309,8 +309,8 @@
         uint8_t completionCode = 0;
         auto response = reinterpret_cast<pldm_msg*>(responseMsg);
 
-        auto decodeRC = decode_new_file_resp(response, responseSize,
-                                             &completionCode);
+        auto decodeRC =
+            decode_new_file_resp(response, responseSize, &completionCode);
         if (decodeRC < 0)
         {
             lg2::error("decode_new_file_resp failed, rc = {RC}", "RC",
diff --git a/extensions/openpower-pels/registry.cpp b/extensions/openpower-pels/registry.cpp
index 05b286a..f96c04e 100644
--- a/extensions/openpower-pels/registry.cpp
+++ b/extensions/openpower-pels/registry.cpp
@@ -549,9 +549,8 @@
  *
  * @return std::vector<RegistryCallout> - The callouts to use
  */
-std::vector<RegistryCallout>
-    getCalloutsWithoutAD(const nlohmann::json& json,
-                         const std::vector<std::string>& systemNames)
+std::vector<RegistryCallout> getCalloutsWithoutAD(
+    const nlohmann::json& json, const std::vector<std::string>& systemNames)
 {
     std::vector<RegistryCallout> calloutEntries;
 
@@ -605,10 +604,9 @@
  *
  * @return std::vector<RegistryCallout> - The callouts to use
  */
-std::vector<RegistryCallout>
-    getCalloutsUsingAD(const nlohmann::json& json,
-                       const std::vector<std::string>& systemNames,
-                       const AdditionalData& additionalData)
+std::vector<RegistryCallout> getCalloutsUsingAD(
+    const nlohmann::json& json, const std::vector<std::string>& systemNames,
+    const AdditionalData& additionalData)
 {
     // This indicates which AD field we'll be using
     auto keyName = json["ADName"].get<std::string>();
@@ -630,10 +628,10 @@
     const auto& callouts = json["CalloutsWithTheirADValues"];
 
     // find the entry with that AD value
-    auto it = std::find_if(callouts.begin(), callouts.end(),
-                           [adValue](const nlohmann::json& j) {
-        return *adValue == j["ADValue"].get<std::string>();
-    });
+    auto it = std::find_if(
+        callouts.begin(), callouts.end(), [adValue](const nlohmann::json& j) {
+            return *adValue == j["ADValue"].get<std::string>();
+        });
 
     if (it == callouts.end())
     {
@@ -728,13 +726,14 @@
     auto& reg = (_registry) ? _registry : registryTmp;
     const auto& registry = reg.value();
     // Find an entry with this name in the PEL array.
-    auto e = std::find_if(registry["PELs"].begin(), registry["PELs"].end(),
-                          [&name, &type](const nlohmann::json& j) {
-        return ((name == j.at("Name").get<std::string>() &&
-                 type == LookupType::name) ||
-                (name == j.at("SRC").at("ReasonCode").get<std::string>() &&
-                 type == LookupType::reasonCode));
-    });
+    auto e = std::find_if(
+        registry["PELs"].begin(), registry["PELs"].end(),
+        [&name, &type](const nlohmann::json& j) {
+            return ((name == j.at("Name").get<std::string>() &&
+                     type == LookupType::name) ||
+                    (name == j.at("SRC").at("ReasonCode").get<std::string>() &&
+                     type == LookupType::reasonCode));
+        });
 
     if (e != registry["PELs"].end())
     {
@@ -801,8 +800,8 @@
 
             if (src.contains("Words6To9"))
             {
-                entry.src.hexwordADFields = helper::getSRCHexwordFields(src,
-                                                                        name);
+                entry.src.hexwordADFields =
+                    helper::getSRCHexwordFields(src, name);
             }
 
             if (src.contains("SymptomIDFields"))
diff --git a/extensions/openpower-pels/registry.hpp b/extensions/openpower-pels/registry.hpp
index cd39b3f..b13b24d 100644
--- a/extensions/openpower-pels/registry.hpp
+++ b/extensions/openpower-pels/registry.hpp
@@ -265,8 +265,7 @@
      */
     explicit Registry(const std::filesystem::path& registryFile,
                       bool loadCallouts) :
-        _registryFile(registryFile),
-        _loadCallouts(loadCallouts)
+        _registryFile(registryFile), _loadCallouts(loadCallouts)
     {}
 
     /**
diff --git a/extensions/openpower-pels/repository.cpp b/extensions/openpower-pels/repository.cpp
index 70738b0..a5a0b8c 100644
--- a/extensions/openpower-pels/repository.cpp
+++ b/extensions/openpower-pels/repository.cpp
@@ -60,9 +60,8 @@
 
 Repository::Repository(const std::filesystem::path& basePath, size_t repoSize,
                        size_t maxNumPELs) :
-    _logPath(basePath / "logs"),
-    _maxRepoSize(repoSize), _maxNumPELs(maxNumPELs),
-    _archivePath(basePath / "logs" / "archive")
+    _logPath(basePath / "logs"), _maxRepoSize(repoSize),
+    _maxNumPELs(maxNumPELs), _archivePath(basePath / "logs" / "archive")
 {
     if (!fs::exists(_logPath))
     {
@@ -495,8 +494,8 @@
 bool Repository::isServiceableSev(const PELAttributes& pel)
 {
     auto sevType = static_cast<SeverityType>(pel.severity & 0xF0);
-    auto sevPVEntry = pel_values::findByValue(pel.severity,
-                                              pel_values::severityValues);
+    auto sevPVEntry =
+        pel_values::findByValue(pel.severity, pel_values::severityValues);
     std::string sevName = std::get<pel_values::registryNamePos>(*sevPVEntry);
 
     bool check1 = (sevType == SeverityType::predictive) ||
@@ -593,18 +592,19 @@
 {
     std::vector<Repository::AttributesReference> attributes;
 
-    std::for_each(
-        _pelAttributes.begin(), _pelAttributes.end(),
-        [&attributes](auto& pelEntry) { attributes.push_back(pelEntry); });
+    std::for_each(_pelAttributes.begin(), _pelAttributes.end(),
+                  [&attributes](auto& pelEntry) {
+                      attributes.push_back(pelEntry);
+                  });
 
     std::sort(attributes.begin(), attributes.end(),
               [order](const auto& left, const auto& right) {
-        if (order == SortOrder::ascending)
-        {
-            return left.get().second.path < right.get().second.path;
-        }
-        return left.get().second.path > right.get().second.path;
-    });
+                  if (order == SortOrder::ascending)
+                  {
+                      return left.get().second.path < right.get().second.path;
+                  }
+                  return left.get().second.path > right.get().second.path;
+              });
 
     return attributes;
 }
@@ -721,16 +721,16 @@
     //   Pass 4: delete all PELs
     static const std::vector<std::function<bool(const PELAttributes& pel)>>
         stateChecks{[](const auto& pel) {
-        return pel.hmcState == TransmissionState::acked;
-    },
+                        return pel.hmcState == TransmissionState::acked;
+                    },
 
                     [](const auto& pel) {
-        return pel.hostState == TransmissionState::acked;
-    },
+                        return pel.hostState == TransmissionState::acked;
+                    },
 
                     [](const auto& pel) {
-        return pel.hostState == TransmissionState::sent;
-    },
+                        return pel.hostState == TransmissionState::sent;
+                    },
 
                     [](const auto& /*pel*/) { return true; }};
 
diff --git a/extensions/openpower-pels/repository.hpp b/extensions/openpower-pels/repository.hpp
index f64efb4..c6683d8 100644
--- a/extensions/openpower-pels/repository.hpp
+++ b/extensions/openpower-pels/repository.hpp
@@ -46,8 +46,7 @@
                       uint16_t flags, TransmissionState hostState,
                       TransmissionState hmcState, uint32_t plid, bool deconfig,
                       bool guard, uint64_t creationTime) :
-            path(p),
-            sizeOnDisk(size), creator(creator), subsystem(subsystem),
+            path(p), sizeOnDisk(size), creator(creator), subsystem(subsystem),
             severity(sev), actionFlags(flags), hostState(hostState),
             hmcState(hmcState), plid(plid), deconfig(deconfig), guard(guard),
             creationTime(creationTime)
diff --git a/extensions/openpower-pels/section_header.hpp b/extensions/openpower-pels/section_header.hpp
index 918a198..2e2993b 100644
--- a/extensions/openpower-pels/section_header.hpp
+++ b/extensions/openpower-pels/section_header.hpp
@@ -34,8 +34,8 @@
      */
     SectionHeader(uint16_t id, uint16_t size, uint8_t version, uint8_t subType,
                   uint16_t componentID) :
-        id(id),
-        size(size), version(version), subType(subType), componentID(componentID)
+        id(id), size(size), version(version), subType(subType),
+        componentID(componentID)
     {}
 
     /**
diff --git a/extensions/openpower-pels/service_indicators.cpp b/extensions/openpower-pels/service_indicators.cpp
index 7e26272..dabf881 100644
--- a/extensions/openpower-pels/service_indicators.cpp
+++ b/extensions/openpower-pels/service_indicators.cpp
@@ -198,8 +198,8 @@
     {
         try
         {
-            auto inventoryPaths = _dataIface.getInventoryFromLocCode(locCode, 0,
-                                                                     true);
+            auto inventoryPaths =
+                _dataIface.getInventoryFromLocCode(locCode, 0, true);
             for (const auto& path : inventoryPaths)
             {
                 if (std::find(paths.begin(), paths.end(), path) == paths.end())
diff --git a/extensions/openpower-pels/severity.cpp b/extensions/openpower-pels/severity.cpp
index acac0f5..36117a4 100644
--- a/extensions/openpower-pels/severity.cpp
+++ b/extensions/openpower-pels/severity.cpp
@@ -78,8 +78,8 @@
     return pelSeverity;
 }
 
-std::optional<LogSeverity> fixupLogSeverity(LogSeverity obmcSeverity,
-                                            SeverityType pelSeverity)
+std::optional<LogSeverity>
+    fixupLogSeverity(LogSeverity obmcSeverity, SeverityType pelSeverity)
 {
     bool isNonErrPelSev = (pelSeverity == SeverityType::nonError) ||
                           (pelSeverity == SeverityType::recovered);
diff --git a/extensions/openpower-pels/severity.hpp b/extensions/openpower-pels/severity.hpp
index a1c1a59..818eb0f 100644
--- a/extensions/openpower-pels/severity.hpp
+++ b/extensions/openpower-pels/severity.hpp
@@ -36,8 +36,7 @@
  *         found, otherwise std::nullopt which means the original one
  *         is good enough.
  */
-std::optional<phosphor::logging::Entry::Level>
-    fixupLogSeverity(phosphor::logging::Entry::Level obmcSeverity,
-                     SeverityType pelSeverity);
+std::optional<phosphor::logging::Entry::Level> fixupLogSeverity(
+    phosphor::logging::Entry::Level obmcSeverity, SeverityType pelSeverity);
 } // namespace pels
 } // namespace openpower
diff --git a/extensions/openpower-pels/src.cpp b/extensions/openpower-pels/src.cpp
index 6d1fab6..628943b 100644
--- a/extensions/openpower-pels/src.cpp
+++ b/extensions/openpower-pels/src.cpp
@@ -158,8 +158,8 @@
     }
     else
     {
-        std::unique_ptr<PyObject, decltype(&pyDecRef)> modPtr(pModule,
-                                                              &pyDecRef);
+        std::unique_ptr<PyObject, decltype(&pyDecRef)> modPtr(
+            pModule, &pyDecRef);
         std::string funcToCall = "parseSRCToJson";
         PyObject* pKey = PyUnicode_FromString(funcToCall.c_str());
         std::unique_ptr<PyObject, decltype(&pyDecRef)> keyPtr(pKey, &pyDecRef);
@@ -179,8 +179,8 @@
         if (PyCallable_Check(pFunc))
         {
             PyObject* pArgs = PyTuple_New(9);
-            std::unique_ptr<PyObject, decltype(&pyDecRef)> argPtr(pArgs,
-                                                                  &pyDecRef);
+            std::unique_ptr<PyObject, decltype(&pyDecRef)> argPtr(
+                pArgs, &pyDecRef);
             for (size_t i = 0; i < 9; i++)
             {
                 std::string arg{"00000000"};
@@ -196,8 +196,8 @@
             {
                 std::unique_ptr<PyObject, decltype(&pyDecRef)> resPtr(
                     pResult, &pyDecRef);
-                PyObject* pBytes = PyUnicode_AsEncodedString(pResult, "utf-8",
-                                                             "~E~");
+                PyObject* pBytes =
+                    PyUnicode_AsEncodedString(pResult, "utf-8", "~E~");
                 std::unique_ptr<PyObject, decltype(&pyDecRef)> pyBytePtr(
                     pBytes, &pyDecRef);
                 const char* output = PyBytes_AS_STRING(pBytes);
@@ -363,8 +363,8 @@
     if (ss)
     {
         auto eventSubsystem = std::stoul(*ss, NULL, 16);
-        std::string subsystem = pv::getValue(eventSubsystem,
-                                             pel_values::subsystemValues);
+        std::string subsystem =
+            pv::getValue(eventSubsystem, pel_values::subsystemValues);
         if (subsystem == "invalid")
         {
             lg2::warning("SRC: Invalid SubSystem value: {VAL}", "VAL", lg2::hex,
@@ -400,8 +400,8 @@
         // Can only set words 6 - 9
         if (!isUserDefinedWord(wordNum))
         {
-            std::string msg = "SRC user data word out of range: " +
-                              std::to_string(wordNum);
+            std::string msg =
+                "SRC user data word out of range: " + std::to_string(wordNum);
             addDebugData(msg);
             continue;
         }
@@ -489,9 +489,8 @@
     return false;
 }
 
-std::optional<std::string> SRC::getErrorDetails(message::Registry& registry,
-                                                DetailLevel type,
-                                                bool toCache) const
+std::optional<std::string> SRC::getErrorDetails(
+    message::Registry& registry, DetailLevel type, bool toCache) const
 {
     const std::string jsonIndent(indentLevel, 0x20);
     std::string errorOut;
@@ -709,10 +708,10 @@
     return printOut;
 }
 
-std::optional<std::string> SRC::getJSON(message::Registry& registry,
-                                        const std::vector<std::string>& plugins
-                                        [[maybe_unused]],
-                                        uint8_t creatorID) const
+std::optional<std::string>
+    SRC::getJSON(message::Registry& registry,
+                 const std::vector<std::string>& plugins [[maybe_unused]],
+                 uint8_t creatorID) const
 {
     std::string ps;
     std::vector<std::string> hexwords;
@@ -759,8 +758,8 @@
 
         jsonInsert(
             ps, "Guarded",
-            pv::boolString.at(_hexData[3] &
-                              static_cast<uint32_t>(ErrorStatusFlags::guarded)),
+            pv::boolString.at(
+                _hexData[3] & static_cast<uint32_t>(ErrorStatusFlags::guarded)),
             1);
     }
 
@@ -828,8 +827,8 @@
                       const nlohmann::json& jsonCallouts,
                       const DataInterfaceBase& dataIface)
 {
-    auto registryCallouts = getRegistryCallouts(regEntry, additionalData,
-                                                dataIface);
+    auto registryCallouts =
+        getRegistryCallouts(regEntry, additionalData, dataIface);
 
     auto item = additionalData.getValue("CALLOUT_INVENTORY_PATH");
     auto priority = additionalData.getValue("CALLOUT_PRIORITY");
@@ -897,16 +896,16 @@
         {
             dataIface.getHWCalloutFields(inventoryPath, fn, ccin, sn);
 
-            CalloutPriority p = priority ? priority.value()
-                                         : CalloutPriority::high;
+            CalloutPriority p =
+                priority ? priority.value() : CalloutPriority::high;
 
-            callout = std::make_unique<src::Callout>(p, locCode, fn, ccin, sn,
-                                                     mrus);
+            callout =
+                std::make_unique<src::Callout>(p, locCode, fn, ccin, sn, mrus);
         }
         catch (const sdbusplus::exception_t& e)
         {
-            std::string msg = "No VPD found for " + inventoryPath + ": " +
-                              e.what();
+            std::string msg =
+                "No VPD found for " + inventoryPath + ": " + e.what();
             addDebugData(msg);
 
             // Just create the callout with empty FRU fields
@@ -940,10 +939,9 @@
     }
 }
 
-std::vector<message::RegistryCallout>
-    SRC::getRegistryCallouts(const message::Entry& regEntry,
-                             const AdditionalData& additionalData,
-                             const DataInterfaceBase& dataIface)
+std::vector<message::RegistryCallout> SRC::getRegistryCallouts(
+    const message::Entry& regEntry, const AdditionalData& additionalData,
+    const DataInterfaceBase& dataIface)
 {
     std::vector<message::RegistryCallout> registryCallouts;
 
@@ -996,8 +994,8 @@
     }
     catch (const std::exception& e)
     {
-        std::string msg = "Error parsing PEL message registry callout JSON: "s +
-                          e.what();
+        std::string msg =
+            "Error parsing PEL message registry callout JSON: "s + e.what();
         addDebugData(msg);
     }
 }
@@ -1027,8 +1025,8 @@
 
     // Via the PEL values table, get the priority enum.
     // The schema will have validated the priority was a valid value.
-    auto priorityIt = pv::findByName(regCallout.priority,
-                                     pv::calloutPriorityValues);
+    auto priorityIt =
+        pv::findByName(regCallout.priority, pv::calloutPriorityValues);
     assert(priorityIt != pv::calloutPriorityValues.end());
     auto priority =
         static_cast<CalloutPriority>(std::get<pv::fieldValuePos>(*priorityIt));
@@ -1145,9 +1143,9 @@
         }
         catch (const std::exception& e)
         {
-            std::string msg = "Invalid CALLOUT_IIC_BUS " + *i2cBus +
-                              " or CALLOUT_IIC_ADDR " + *i2cAddr +
-                              " in AdditionalData property";
+            std::string msg =
+                "Invalid CALLOUT_IIC_BUS " + *i2cBus + " or CALLOUT_IIC_ADDR " +
+                *i2cAddr + " in AdditionalData property";
             addDebugData(msg);
             return;
         }
@@ -1566,8 +1564,8 @@
 
         if (std::all_of(progressCodeString.begin(), progressCodeString.end(),
                         [](char c) {
-            return std::isxdigit(static_cast<unsigned char>(c));
-        }))
+                            return std::isxdigit(static_cast<unsigned char>(c));
+                        }))
         {
             progressCode = std::stoul(progressCodeString, nullptr, 16);
         }
diff --git a/extensions/openpower-pels/src.hpp b/extensions/openpower-pels/src.hpp
index a09f286..edd26e1 100644
--- a/extensions/openpower-pels/src.hpp
+++ b/extensions/openpower-pels/src.hpp
@@ -272,9 +272,9 @@
      * @param[in] toCache - boolean to cache registry in memory, default=false
      * @return std::optional<std::string> - Error details
      */
-    std::optional<std::string> getErrorDetails(message::Registry& registry,
-                                               DetailLevel type,
-                                               bool toCache = false) const;
+    std::optional<std::string>
+        getErrorDetails(message::Registry& registry, DetailLevel type,
+                        bool toCache = false) const;
 
     /**
      * @brief Says if this SRC was created by the BMC (i.e. this code).
@@ -470,12 +470,12 @@
      * @param[in] dataIface - The DataInterface object
      * @param[in] mrus - The MRUs to add to the callout
      */
-    void
-        addInventoryCallout(const std::string& inventoryPath,
-                            const std::optional<CalloutPriority>& priority,
-                            const std::optional<std::string>& locationCode,
-                            const DataInterfaceBase& dataIface,
-                            const std::vector<src::MRU::MRUCallout>& mrus = {});
+    void addInventoryCallout(
+        const std::string& inventoryPath,
+        const std::optional<CalloutPriority>& priority,
+        const std::optional<std::string>& locationCode,
+        const DataInterfaceBase& dataIface,
+        const std::vector<src::MRU::MRUCallout>& mrus = {});
 
     /**
      * @brief Returns the callouts to use from the registry entry.
@@ -484,10 +484,9 @@
      * @param[in] additionalData - The AdditionalData property
      * @param[in] dataIface - The DataInterface object
      */
-    std::vector<message::RegistryCallout>
-        getRegistryCallouts(const message::Entry& regEntry,
-                            const AdditionalData& additionalData,
-                            const DataInterfaceBase& dataIface);
+    std::vector<message::RegistryCallout> getRegistryCallouts(
+        const message::Entry& regEntry, const AdditionalData& additionalData,
+        const DataInterfaceBase& dataIface);
 
     /**
      * @brief Adds the FRU callouts from the list of registry callouts
diff --git a/extensions/openpower-pels/temporary_file.cpp b/extensions/openpower-pels/temporary_file.cpp
index 7ff1365..8405234 100644
--- a/extensions/openpower-pels/temporary_file.cpp
+++ b/extensions/openpower-pels/temporary_file.cpp
@@ -18,8 +18,8 @@
 TemporaryFile::TemporaryFile(const char* data, const uint32_t len)
 {
     // Build template path required by mkstemp()
-    std::string templatePath = fs::temp_directory_path() /
-                               "phosphor-logging-XXXXXX";
+    std::string templatePath =
+        fs::temp_directory_path() / "phosphor-logging-XXXXXX";
 
     // Generate unique file name, create file, and open it.  The XXXXXX
     // characters are replaced by mkstemp() to make the file name unique.
@@ -37,8 +37,8 @@
         // Delete temporary file.  The destructor won't be called because the
         // exception below causes this constructor to exit without completing.
         remove();
-        throw std::runtime_error{std::string{"Unable to update file: "} +
-                                 strerror(errno)};
+        throw std::runtime_error{
+            std::string{"Unable to update file: "} + strerror(errno)};
     }
 
     // Store path to temporary file
diff --git a/extensions/openpower-pels/tools/peltool.cpp b/extensions/openpower-pels/tools/peltool.cpp
index a4b7f59..85fe9d1 100644
--- a/extensions/openpower-pels/tools/peltool.cpp
+++ b/extensions/openpower-pels/tools/peltool.cpp
@@ -301,11 +301,10 @@
  * @return std::string - JSON string of PEL entry (empty if fullPEL is true)
  */
 template <typename T>
-std::string genPELJSON(T itr, bool hidden, bool includeInfo, bool critSysTerm,
-                       bool fullPEL, bool& foundPEL,
-                       const std::optional<std::regex>& scrubRegex,
-                       const std::vector<std::string>& plugins, bool hexDump,
-                       bool archive)
+std::string genPELJSON(
+    T itr, bool hidden, bool includeInfo, bool critSysTerm, bool fullPEL,
+    bool& foundPEL, const std::optional<std::regex>& scrubRegex,
+    const std::vector<std::string>& plugins, bool hexDump, bool archive)
 {
     std::string val;
     std::string listStr;
@@ -497,8 +496,8 @@
     // Sort the pairs based on second time parameter
     std::sort(PELs.begin(), PELs.end(),
               [](const auto& left, const auto& right) {
-        return left.second < right.second;
-    });
+                  return left.second < right.second;
+              });
 
     bool foundPEL = false;
 
diff --git a/extensions/openpower-pels/user_data.cpp b/extensions/openpower-pels/user_data.cpp
index cb4acd1..72b216c 100644
--- a/extensions/openpower-pels/user_data.cpp
+++ b/extensions/openpower-pels/user_data.cpp
@@ -94,10 +94,9 @@
     }
 }
 
-std::optional<std::string>
-    UserData::getJSON(uint8_t creatorID [[maybe_unused]],
-                      const std::vector<std::string>& plugins
-                      [[maybe_unused]]) const
+std::optional<std::string> UserData::getJSON(
+    uint8_t creatorID [[maybe_unused]],
+    const std::vector<std::string>& plugins [[maybe_unused]]) const
 {
 #ifdef PELTOOL
     return user_data::getJSON(_header.componentID, _header.subType,
diff --git a/extensions/openpower-pels/user_data_json.cpp b/extensions/openpower-pels/user_data_json.cpp
index 34da02f..0d621ec 100644
--- a/extensions/openpower-pels/user_data_json.cpp
+++ b/extensions/openpower-pels/user_data_json.cpp
@@ -253,10 +253,9 @@
  * @return std::optional<std::string> - The JSON string if it could be created,
  *                                      else std::nullopt
  */
-std::optional<std::string> getPythonJSON(uint16_t componentID, uint8_t subType,
-                                         uint8_t version,
-                                         const std::vector<uint8_t>& data,
-                                         uint8_t creatorID)
+std::optional<std::string>
+    getPythonJSON(uint16_t componentID, uint8_t subType, uint8_t version,
+                  const std::vector<uint8_t>& data, uint8_t creatorID)
 {
     PyObject *pName, *pModule, *eType, *eValue, *eTraceback, *pKey;
     std::string pErrStr;
@@ -291,8 +290,8 @@
     }
     else
     {
-        std::unique_ptr<PyObject, decltype(&pyDecRef)> modPtr(pModule,
-                                                              &pyDecRef);
+        std::unique_ptr<PyObject, decltype(&pyDecRef)> modPtr(
+            pModule, &pyDecRef);
         std::string funcToCall = "parseUDToJson";
         pKey = PyUnicode_FromString(funcToCall.c_str());
         std::unique_ptr<PyObject, decltype(&pyDecRef)> keyPtr(pKey, &pyDecRef);
@@ -315,8 +314,8 @@
         {
             auto ud = data.data();
             PyObject* pArgs = PyTuple_New(3);
-            std::unique_ptr<PyObject, decltype(&pyDecRef)> argPtr(pArgs,
-                                                                  &pyDecRef);
+            std::unique_ptr<PyObject, decltype(&pyDecRef)> argPtr(
+                pArgs, &pyDecRef);
             PyTuple_SetItem(pArgs, 0,
                             PyLong_FromUnsignedLong((unsigned long)subType));
             PyTuple_SetItem(pArgs, 1,
@@ -331,8 +330,8 @@
             {
                 std::unique_ptr<PyObject, decltype(&pyDecRef)> resPtr(
                     pResult, &pyDecRef);
-                PyObject* pBytes = PyUnicode_AsEncodedString(pResult, "utf-8",
-                                                             "~E~");
+                PyObject* pBytes =
+                    PyUnicode_AsEncodedString(pResult, "utf-8", "~E~");
                 std::unique_ptr<PyObject, decltype(&pyDecRef)> pyBytePtr(
                     pBytes, &pyDecRef);
                 const char* output = PyBytes_AS_STRING(pBytes);
@@ -393,11 +392,10 @@
     return std::nullopt;
 }
 
-std::optional<std::string> getJSON(uint16_t componentID, uint8_t subType,
-                                   uint8_t version,
-                                   const std::vector<uint8_t>& data,
-                                   uint8_t creatorID,
-                                   const std::vector<std::string>& plugins)
+std::optional<std::string>
+    getJSON(uint16_t componentID, uint8_t subType, uint8_t version,
+            const std::vector<uint8_t>& data, uint8_t creatorID,
+            const std::vector<std::string>& plugins)
 {
     std::string subsystem = getNumberString("%c", tolower(creatorID));
     std::string component = getNumberString("%04x", componentID);
diff --git a/extensions/openpower-pels/user_data_json.hpp b/extensions/openpower-pels/user_data_json.hpp
index 930e378..aaf146a 100644
--- a/extensions/openpower-pels/user_data_json.hpp
+++ b/extensions/openpower-pels/user_data_json.hpp
@@ -20,10 +20,9 @@
  * @return std::optional<std::string> - The JSON string if it could be created,
  *                                      else std::nullopt.
  */
-std::optional<std::string> getJSON(uint16_t componentID, uint8_t subType,
-                                   uint8_t version,
-                                   const std::vector<uint8_t>& data,
-                                   uint8_t creatorID,
-                                   const std::vector<std::string>& plugins);
+std::optional<std::string>
+    getJSON(uint16_t componentID, uint8_t subType, uint8_t version,
+            const std::vector<uint8_t>& data, uint8_t creatorID,
+            const std::vector<std::string>& plugins);
 
 } // namespace openpower::pels::user_data
diff --git a/extensions/openpower-pels/user_header.cpp b/extensions/openpower-pels/user_header.cpp
index 3088c13..1cce95c 100644
--- a/extensions/openpower-pels/user_header.cpp
+++ b/extensions/openpower-pels/user_header.cpp
@@ -64,8 +64,8 @@
     if (ss)
     {
         auto eventSubsystem = std::stoul(*ss, NULL, 16);
-        std::string subsystemString = pv::getValue(eventSubsystem,
-                                                   pel_values::subsystemValues);
+        std::string subsystemString =
+            pv::getValue(eventSubsystem, pel_values::subsystemValues);
         if (subsystemString == "invalid")
         {
             lg2::warning(
@@ -260,8 +260,8 @@
     subsystem = pv::getValue(_eventSubsystem, pel_values::subsystemValues);
     eventScope = pv::getValue(_eventScope, pel_values::eventScopeValues);
     eventType = pv::getValue(_eventType, pel_values::eventTypeValues);
-    actionFlags = pv::getValuesBitwise(_actionFlags,
-                                       pel_values::actionFlagsValues);
+    actionFlags =
+        pv::getValuesBitwise(_actionFlags, pel_values::actionFlagsValues);
 
     std::string hostState{"Invalid"};
     std::string hmcState{"Invalid"};