diff --git a/.clang-format b/.clang-format
index d43e884..28e3328 100644
--- a/.clang-format
+++ b/.clang-format
@@ -87,7 +87,7 @@
 IndentWrappedFunctionNames: true
 InsertNewlineAtEOF: true
 KeepEmptyLinesAtTheStartOfBlocks: false
-LambdaBodyIndentation: OuterScope
+LambdaBodyIndentation: Signature
 LineEnding: LF
 MacroBlockBegin: ''
 MacroBlockEnd:   ''
@@ -98,13 +98,14 @@
 ObjCSpaceBeforeProtocolList: true
 PackConstructorInitializers: BinPack
 PenaltyBreakAssignment: 25
-PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakBeforeFirstCallParameter: 50
 PenaltyBreakComment: 300
 PenaltyBreakFirstLessLess: 120
 PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
-PenaltyIndentedWhitespace: 0
+PenaltyIndentedWhitespace: 1
 PointerAlignment: Left
 QualifierAlignment: Left
 ReferenceAlignment: Left
diff --git a/elog_block.hpp b/elog_block.hpp
index 1d25e6c..823dbd1 100644
--- a/elog_block.hpp
+++ b/elog_block.hpp
@@ -43,11 +43,11 @@
     Block(sdbusplus::bus_t& bus, const std::string& path, uint32_t entryId) :
         BlockIface(bus, path.c_str()), entryId(entryId)
     {
-        std::string entryPath{std::string(OBJ_ENTRY) + '/' +
-                              std::to_string(entryId)};
-        AssociationList assoc{std::make_tuple(std::string{"blocking_error"},
-                                              std::string{"blocking_obj"},
-                                              entryPath)};
+        std::string entryPath{
+            std::string(OBJ_ENTRY) + '/' + std::to_string(entryId)};
+        AssociationList assoc{
+            std::make_tuple(std::string{"blocking_error"},
+                            std::string{"blocking_obj"}, entryPath)};
         associations(std::move(assoc));
     };
 
diff --git a/elog_entry.hpp b/elog_entry.hpp
index d8b9025..d4fa5ae 100644
--- a/elog_entry.hpp
+++ b/elog_entry.hpp
@@ -79,8 +79,8 @@
         associations(std::move(objects), true);
         // Store a copy of associations in case we need to recreate
         assocs = associations();
-        sdbusplus::server::xyz::openbmc_project::logging::Entry::resolved(false,
-                                                                          true);
+        sdbusplus::server::xyz::openbmc_project::logging::Entry::resolved(
+            false, true);
 
         version(fwVersion, true);
         purpose(VersionPurpose::BMC, true);
diff --git a/elog_meta.cpp b/elog_meta.cpp
index e8d7174..0131c2f 100644
--- a/elog_meta.cpp
+++ b/elog_meta.cpp
@@ -49,9 +49,9 @@
     auto iter = metadata.find(match);
     if (metadata.end() != iter)
     {
-        list.emplace_back(std::make_tuple(CALLOUT_FWD_ASSOCIATION,
-                                          CALLOUT_REV_ASSOCIATION,
-                                          std::string(iter->second.c_str())));
+        list.emplace_back(
+            std::make_tuple(CALLOUT_FWD_ASSOCIATION, CALLOUT_REV_ASSOCIATION,
+                            std::string(iter->second.c_str())));
     }
 }
 
diff --git a/elog_meta.hpp b/elog_meta.hpp
index 49ebd59..4273a4c 100644
--- a/elog_meta.hpp
+++ b/elog_meta.hpp
@@ -81,18 +81,16 @@
 // for this metadata.
 using namespace example::xyz::openbmc_project::example::elog;
 template <>
-inline void
-    build<TestErrorTwo::DEV_ID>(const std::string& /*match*/,
-                                const std::vector<std::string>& /*data*/,
-                                AssociationList& /*list*/)
+inline void build<TestErrorTwo::DEV_ID>(
+    const std::string& /*match*/, const std::vector<std::string>& /*data*/,
+    AssociationList& /*list*/)
 {}
 
 template <>
-inline void
-    build<example::xyz::openbmc_project::example::device::Callout::
-              CALLOUT_DEVICE_PATH_TEST>(const std::string& match,
-                                        const std::vector<std::string>& data,
-                                        AssociationList& list)
+inline void build<example::xyz::openbmc_project::example::device::Callout::
+                      CALLOUT_DEVICE_PATH_TEST>(
+    const std::string& match, const std::vector<std::string>& data,
+    AssociationList& list)
 {
     std::map<std::string, std::string> metadata;
     parse(data, metadata);
diff --git a/elog_serialize.hpp b/elog_serialize.hpp
index 720c816..38ff424 100644
--- a/elog_serialize.hpp
+++ b/elog_serialize.hpp
@@ -38,9 +38,8 @@
  *                   be placed.
  *  @return fs::path - pathname of persisted error file
  */
-fs::path
-    getEntrySerializePath(uint32_t id,
-                          const fs::path& dir = fs::path(ERRLOG_PERSIST_PATH));
+fs::path getEntrySerializePath(
+    uint32_t id, const fs::path& dir = fs::path(ERRLOG_PERSIST_PATH));
 
 } // namespace logging
 } // namespace phosphor
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"};
diff --git a/lib/include/phosphor-logging/lg2/conversion.hpp b/lib/include/phosphor-logging/lg2/conversion.hpp
index b90790e..7138fe5 100644
--- a/lib/include/phosphor-logging/lg2/conversion.hpp
+++ b/lib/include/phosphor-logging/lg2/conversion.hpp
@@ -29,8 +29,8 @@
 template <typename T>
 concept string_like_type =
     (std::constructible_from<std::string_view, T> ||
-     std::same_as<std::filesystem::path,
-                  std::decay_t<T>>)&&!std::same_as<std::nullptr_t, T>;
+     std::same_as<std::filesystem::path, std::decay_t<T>>) &&
+    !std::same_as<std::nullptr_t, T>;
 
 /** Concept to determine if an item acts like a pointer.
  *
@@ -38,8 +38,9 @@
  *  pointer.
  */
 template <typename T>
-concept pointer_type = (std::is_pointer_v<T> ||
-                        std::same_as<std::nullptr_t, T>)&&!string_like_type<T>;
+concept pointer_type =
+    (std::is_pointer_v<T> || std::same_as<std::nullptr_t, T>) &&
+    !string_like_type<T>;
 
 /** Concept to determine if an item acts like an unsigned_integral.
  *
@@ -47,8 +48,8 @@
  *  `True` and `False` strings.
  */
 template <typename T>
-concept unsigned_integral_except_bool = !std::same_as<T, bool> &&
-                                        std::unsigned_integral<T>;
+concept unsigned_integral_except_bool =
+    !std::same_as<T, bool> && std::unsigned_integral<T>;
 
 template <typename T>
 concept sdbusplus_enum = sdbusplus::message::has_convert_from_string_v<T>;
@@ -64,8 +65,8 @@
 concept has_to_string = requires(T&& t) { to_string(t); };
 
 template <typename T>
-concept is_raw_enum = std::is_enum_v<std::decay_t<T>> && !sdbusplus_enum<T> &&
-                      !has_to_string<T>;
+concept is_raw_enum =
+    std::is_enum_v<std::decay_t<T>> && !sdbusplus_enum<T> && !has_to_string<T>;
 
 /** Concept listing all of the types we know how to convert into a format
  *  for logging.
@@ -238,8 +239,8 @@
 
     // Cast (void*) to a hex-formatted uint64 using the target's pointer-size
     // to determine field-width.
-    constexpr static auto new_f = sizeof(void*) == 4 ? field32.value
-                                                     : field64.value;
+    constexpr static auto new_f =
+        sizeof(void*) == 4 ? field32.value : field64.value;
 
     return std::make_tuple(h, new_f | (hex | unsigned_val).value,
                            reinterpret_cast<uint64_t>(v));
diff --git a/lib/lg2_logger.cpp b/lib/lg2_logger.cpp
index fcf129f..57fc029 100644
--- a/lib/lg2_logger.cpp
+++ b/lib/lg2_logger.cpp
@@ -209,10 +209,10 @@
 
 // Use the cerr output method if we are on a TTY or if explicitly set via
 // environment variable.
-static auto extra_output_method = (isatty(fileno(stderr)) ||
-                                   nullptr != getenv("LG2_FORCE_STDERR"))
-                                      ? cerr_extra_output
-                                      : noop_extra_output;
+static auto extra_output_method =
+    (isatty(fileno(stderr)) || nullptr != getenv("LG2_FORCE_STDERR"))
+        ? cerr_extra_output
+        : noop_extra_output;
 
 // Do_log implementation.
 void do_log(level l, const std::source_location& s, const char* m, ...)
diff --git a/log_manager.cpp b/log_manager.cpp
index 4cdbc4e..4643bff 100644
--- a/log_manager.cpp
+++ b/log_manager.cpp
@@ -384,8 +384,8 @@
     // Verify we don't already have this entry blocking
     auto it = find_if(this->blockingErrors.begin(), this->blockingErrors.end(),
                       [&](const std::unique_ptr<Block>& obj) {
-        return obj->entryId == entryId;
-    });
+                          return obj->entryId == entryId;
+                      });
     if (it != this->blockingErrors.end())
     {
         // Already recorded so just return
@@ -396,8 +396,8 @@
 
     lg2::info("QuiesceOnError set and callout present");
 
-    auto blockPath = std::string(OBJ_LOGGING) + "/block" +
-                     std::to_string(entryId);
+    auto blockPath =
+        std::string(OBJ_LOGGING) + "/block" + std::to_string(entryId);
     auto blockObj = std::make_unique<Block>(this->busLog, blockPath, entryId);
     this->blockingErrors.push_back(std::move(blockObj));
 
@@ -470,8 +470,8 @@
     // First look for blocking object and remove
     auto it = find_if(blockingErrors.begin(), blockingErrors.end(),
                       [&](const std::unique_ptr<Block>& obj) {
-        return obj->entryId == entryId;
-    });
+                          return obj->entryId == entryId;
+                      });
     if (it != blockingErrors.end())
     {
         blockingErrors.erase(it);
diff --git a/log_manager.hpp b/log_manager.hpp
index e47d6b5..cc42d8a 100644
--- a/log_manager.hpp
+++ b/log_manager.hpp
@@ -73,7 +73,7 @@
      */
     Manager(sdbusplus::bus_t& bus, const char* objPath) :
         details::ServerObject<details::ManagerIface>(bus, objPath), busLog(bus),
-        entryId(0), fwVersion(readFWVersion()){};
+        entryId(0), fwVersion(readFWVersion()) {};
 
     /*
      * @fn commit()
@@ -354,7 +354,7 @@
             bus, path.c_str(),
             details::ServerObject<DeleteAllIface,
                                   CreateIface>::action::defer_emit),
-        manager(manager){};
+        manager(manager) {};
 
     /** @brief Delete all d-bus objects.
      */
diff --git a/logging_test.cpp b/logging_test.cpp
index c0350f5..87d1da9 100644
--- a/logging_test.cpp
+++ b/logging_test.cpp
@@ -126,8 +126,8 @@
     if (rc)
         return (rc);
 
-    rc = validate_journal(TestErrorOne::FILE_NAME::str_short,
-                          "elog_test_3.txt");
+    rc =
+        validate_journal(TestErrorOne::FILE_NAME::str_short, "elog_test_3.txt");
     if (rc)
         return (rc);
 
@@ -171,8 +171,8 @@
     if (rc)
         return (rc);
 
-    rc = validate_journal(TestErrorOne::FILE_NAME::str_short,
-                          "elog_test_4.txt");
+    rc =
+        validate_journal(TestErrorOne::FILE_NAME::str_short, "elog_test_4.txt");
     if (rc)
         return (rc);
 
diff --git a/phosphor-rsyslog-config/server-conf.cpp b/phosphor-rsyslog-config/server-conf.cpp
index 36149a5..f2a7aa8 100644
--- a/phosphor-rsyslog-config/server-conf.cpp
+++ b/phosphor-rsyslog-config/server-conf.cpp
@@ -87,8 +87,8 @@
                 // There is no ':', or no more content after ':', invalid config
                 return {};
             }
-            serverAddress = line.substr(posColonLeft + 1,
-                                        posColonRight - posColonLeft - 1);
+            serverAddress =
+                line.substr(posColonLeft + 1, posColonRight - posColonLeft - 1);
             serverPort = line.substr(posColonRight + 2);
         }
         else
diff --git a/test/elog_errorwrap_test.hpp b/test/elog_errorwrap_test.hpp
index 5d9edba..d8b1295 100644
--- a/test/elog_errorwrap_test.hpp
+++ b/test/elog_errorwrap_test.hpp
@@ -70,7 +70,7 @@
 {
   public:
     MockJournal(sdbusplus::bus_t& bus, const char* objPath) :
-        Manager(bus, objPath){};
+        Manager(bus, objPath) {};
     MOCK_METHOD0(journalSync, void());
     MOCK_METHOD2(sd_journal_open, int(sd_journal**, int));
     MOCK_METHOD4(sd_journal_get_data,
diff --git a/test/openpower-pels/device_callouts_test.cpp b/test/openpower-pels/device_callouts_test.cpp
index e02360a..ec8e182 100644
--- a/test/openpower-pels/device_callouts_test.cpp
+++ b/test/openpower-pels/device_callouts_test.cpp
@@ -519,9 +519,9 @@
             "slave@01:00/01:01:00:06/sbefifo2-dev0/occ-hwmon.2",
             systemTypes);
 
-        std::vector<Callout> expected{{"H", "P1-C19",
-                                       "/chassis/motherboard/cpu0", "core",
-                                       "FSI: links: 0-1 dest: proc-0 target"}};
+        std::vector<Callout> expected{
+            {"H", "P1-C19", "/chassis/motherboard/cpu0", "core",
+             "FSI: links: 0-1 dest: proc-0 target"}};
 
         EXPECT_EQ(callouts, expected);
 
diff --git a/test/openpower-pels/failing_mtms_test.cpp b/test/openpower-pels/failing_mtms_test.cpp
index e377482..68355e2 100644
--- a/test/openpower-pels/failing_mtms_test.cpp
+++ b/test/openpower-pels/failing_mtms_test.cpp
@@ -84,10 +84,10 @@
 
 TEST(FailingMTMSTest, StreamConstructorTest)
 {
-    std::vector<uint8_t> data{0x4D, 0x54, 0x00, 0x1C, 0x01, 0x00, 0x20,
-                              0x00, 'T',  'T',  'T',  'T',  '-',  'M',
-                              'M',  'M',  '1',  '2',  '3',  '4',  '5',
-                              '6',  '7',  '8',  '9',  'A',  'B',  'C'};
+    std::vector<uint8_t> data{
+        0x4D, 0x54, 0x00, 0x1C, 0x01, 0x00, 0x20, 0x00, 'T', 'T',
+        'T',  'T',  '-',  'M',  'M',  'M',  '1',  '2',  '3', '4',
+        '5',  '6',  '7',  '8',  '9',  'A',  'B',  'C'};
     Stream stream{data};
     FailingMTMS fm{stream};
 
@@ -117,10 +117,10 @@
 
 TEST(FailingMTMSTest, FlattenTest)
 {
-    std::vector<uint8_t> data{0x4D, 0x54, 0x00, 0x1C, 0x01, 0x00, 0x20,
-                              0x00, 'T',  'T',  'T',  'T',  '-',  'M',
-                              'M',  'M',  '1',  '2',  '3',  '4',  '5',
-                              '6',  '7',  '8',  '9',  'A',  'B',  'C'};
+    std::vector<uint8_t> data{
+        0x4D, 0x54, 0x00, 0x1C, 0x01, 0x00, 0x20, 0x00, 'T', 'T',
+        'T',  'T',  '-',  'M',  'M',  'M',  '1',  '2',  '3', '4',
+        '5',  '6',  '7',  '8',  '9',  'A',  'B',  'C'};
     Stream stream{data};
     FailingMTMS fm{stream};
 
diff --git a/test/openpower-pels/host_notifier_test.cpp b/test/openpower-pels/host_notifier_test.cpp
index 121254c..8e7380e 100644
--- a/test/openpower-pels/host_notifier_test.cpp
+++ b/test/openpower-pels/host_notifier_test.cpp
@@ -47,8 +47,8 @@
 
         ON_CALL(dataIface, getHostPELEnablement).WillByDefault(Return(true));
 
-        hostIface = std::make_unique<NiceMock<MockHostInterface>>(event,
-                                                                  dataIface);
+        hostIface =
+            std::make_unique<NiceMock<MockHostInterface>>(event, dataIface);
 
         mockHostIface = reinterpret_cast<MockHostInterface*>(hostIface.get());
 
@@ -121,11 +121,11 @@
 {
     bool hostState = false;
     bool called = false;
-    DataInterfaceBase::HostStateChangeFunc func = [&hostState,
-                                                   &called](bool state) {
-        hostState = state;
-        called = true;
-    };
+    DataInterfaceBase::HostStateChangeFunc func =
+        [&hostState, &called](bool state) {
+            hostState = state;
+            called = true;
+        };
 
     dataIface.subscribeToHostStateChange("test", func);
 
diff --git a/test/openpower-pels/mocks.hpp b/test/openpower-pels/mocks.hpp
index 2e06627..dd9e3c1 100644
--- a/test/openpower-pels/mocks.hpp
+++ b/test/openpower-pels/mocks.hpp
@@ -202,10 +202,10 @@
         int fd = open(_fifo.c_str(), O_NONBLOCK | O_RDWR);
         EXPECT_TRUE(fd >= 0) << "Unable to open FIFO";
 
-        auto callback = [this](sdeventplus::source::IO& source, int fd,
-                               uint32_t events) {
-            this->receive(source, fd, events, nullptr);
-        };
+        auto callback =
+            [this](sdeventplus::source::IO& source, int fd, uint32_t events) {
+                this->receive(source, fd, events, nullptr);
+            };
 
         try
         {
diff --git a/test/openpower-pels/pel_manager_test.cpp b/test/openpower-pels/pel_manager_test.cpp
index f1bc57a..3689bdf 100644
--- a/test/openpower-pels/pel_manager_test.cpp
+++ b/test/openpower-pels/pel_manager_test.cpp
@@ -392,11 +392,11 @@
 
     std::unique_ptr<JournalBase> journal = std::make_unique<MockJournal>();
 
-    Manager manager{logManager, std::move(dataIface),
-                    std::bind(std::mem_fn(&TestLogger::log), &logger,
-                              std::placeholders::_1, std::placeholders::_2,
-                              std::placeholders::_3),
-                    std::move(journal)};
+    Manager manager{
+        logManager, std::move(dataIface),
+        std::bind(std::mem_fn(&TestLogger::log), &logger, std::placeholders::_1,
+                  std::placeholders::_2, std::placeholders::_3),
+        std::move(journal)};
 
     // Create a PEL, write it to a file, and pass that filename into
     // the create function so there's one in the repo.
diff --git a/test/openpower-pels/pel_test.cpp b/test/openpower-pels/pel_test.cpp
index cf54e9c..8369b05 100644
--- a/test/openpower-pels/pel_test.cpp
+++ b/test/openpower-pels/pel_test.cpp
@@ -211,9 +211,10 @@
         // in the registry, so the constructor should set them.
         regEntry.actionFlags = std::nullopt;
 
-        PEL pel2{
-            regEntry, 42,   timestamp, phosphor::logging::Entry::Level::Error,
-            ad,       ffdc, dataIface, journal};
+        PEL pel2{regEntry,  42,
+                 timestamp, phosphor::logging::Entry::Level::Error,
+                 ad,        ffdc,
+                 dataIface, journal};
 
         EXPECT_EQ(pel2.userHeader().actionFlags(), 0xA800);
     }
@@ -251,11 +252,11 @@
 
     // Make sure that there are still 2 UD sections.
     const auto& optSections = pel.optionalSections();
-    auto udCount = std::count_if(optSections.begin(), optSections.end(),
-                                 [](const auto& section) {
-        return section->header().id ==
-               static_cast<uint16_t>(SectionID::userData);
-    });
+    auto udCount = std::count_if(
+        optSections.begin(), optSections.end(), [](const auto& section) {
+            return section->header().id ==
+                   static_cast<uint16_t>(SectionID::userData);
+        });
 
     EXPECT_EQ(udCount, 2); // AD section and sysInfo section
 }
@@ -266,15 +267,15 @@
 {
     auto data = pelDataFactory(TestPELType::pelSimple);
 
-    std::vector<uint8_t> section1{0x58, 0x58, // ID 'XX'
-                                  0x00, 0x18, // Size
-                                  0x01, 0x02, // version, subtype
-                                  0x03, 0x04, // comp ID
+    std::vector<uint8_t> section1{
+        0x58, 0x58, // ID 'XX'
+        0x00, 0x18, // Size
+        0x01, 0x02, // version, subtype
+        0x03, 0x04, // comp ID
 
-                                  // some data
-                                  0x20, 0x30, 0x05, 0x09, 0x11, 0x1E, 0x1, 0x63,
-                                  0x20, 0x31, 0x06, 0x0F, 0x09, 0x22, 0x3A,
-                                  0x00};
+        // some data
+        0x20, 0x30, 0x05, 0x09, 0x11, 0x1E, 0x1, 0x63, 0x20, 0x31, 0x06, 0x0F,
+        0x09, 0x22, 0x3A, 0x00};
 
     std::vector<uint8_t> section2{
         0x59, 0x59, // ID 'YY'
@@ -848,10 +849,10 @@
         .WillOnce(Return(std::vector<std::string>{
             "/xyz/openbmc_project/inventory/chassis/motherboard/cpu0"}));
 
-    EXPECT_CALL(
-        dataIface,
-        getHWCalloutFields(
-            "/xyz/openbmc_project/inventory/chassis/motherboard/cpu0", _, _, _))
+    EXPECT_CALL(dataIface,
+                getHWCalloutFields(
+                    "/xyz/openbmc_project/inventory/chassis/motherboard/cpu0",
+                    _, _, _))
         .WillOnce(DoAll(SetArgReferee<1>("1234567"), SetArgReferee<2>("CCCC"),
                         SetArgReferee<3>("123456789ABC")));
 
@@ -868,9 +869,10 @@
 
         AdditionalData ad{data};
 
-        PEL pel{
-            regEntry, 42,   timestamp, phosphor::logging::Entry::Level::Error,
-            ad,       ffdc, dataIface, journal};
+        PEL pel{regEntry,  42,
+                timestamp, phosphor::logging::Entry::Level::Error,
+                ad,        ffdc,
+                dataIface, journal};
 
         ASSERT_TRUE(pel.primarySRC().value()->callouts());
         auto& callouts = pel.primarySRC().value()->callouts()->callouts();
@@ -918,9 +920,10 @@
 
         AdditionalData ad{data};
 
-        PEL pel{
-            regEntry, 42,   timestamp, phosphor::logging::Entry::Level::Error,
-            ad,       ffdc, dataIface, journal};
+        PEL pel{regEntry,  42,
+                timestamp, phosphor::logging::Entry::Level::Error,
+                ad,        ffdc,
+                dataIface, journal};
 
         // no callouts
         EXPECT_FALSE(pel.primarySRC().value()->callouts());
@@ -1157,9 +1160,10 @@
 
         EXPECT_CALL(journal, getMessages("", 5)).WillOnce(Return(msgs));
 
-        PEL pel{
-            regEntry, 42,   timestamp, phosphor::logging::Entry::Level::Error,
-            ad,       ffdc, dataIface, journal};
+        PEL pel{regEntry,  42,
+                timestamp, phosphor::logging::Entry::Level::Error,
+                ad,        ffdc,
+                dataIface, journal};
 
         // Check the generated UserData section
         std::string expected{"test1 test2\ntest3 test4\ntest5 test6\n4\n5\n"};
@@ -1183,9 +1187,10 @@
             .WillOnce(
                 Return(std::vector<std::string>{std::string(20000, 'x')}));
 
-        PEL pel{
-            regEntry, 42,   timestamp, phosphor::logging::Entry::Level::Error,
-            ad,       ffdc, dataIface, journal};
+        PEL pel{regEntry,  42,
+                timestamp, phosphor::logging::Entry::Level::Error,
+                ad,        ffdc,
+                dataIface, journal};
 
         // Check for 1 fewer sections than in the previous PEL
         EXPECT_EQ(pel.privateHeader().sectionCount(), pelSectsWithOneUD - 1);
@@ -1214,9 +1219,10 @@
         EXPECT_CALL(journal, getMessages("app2", 4)).WillOnce(Return(app2));
         EXPECT_CALL(journal, getMessages("app3", 1)).WillOnce(Return(app3));
 
-        PEL pel{
-            regEntry, 42,   timestamp, phosphor::logging::Entry::Level::Error,
-            ad,       ffdc, dataIface, journal};
+        PEL pel{regEntry,  42,
+                timestamp, phosphor::logging::Entry::Level::Error,
+                ad,        ffdc,
+                dataIface, journal};
 
         // Two more sections than the 1 extra UD section in the first testcase
         ASSERT_EQ(pel.privateHeader().sectionCount(), pelSectsWithOneUD + 2);
@@ -1250,9 +1256,10 @@
             .WillOnce(
                 Return(std::vector<std::string>{std::string(20000, 'x')}));
 
-        PEL pel{
-            regEntry, 42,   timestamp, phosphor::logging::Entry::Level::Error,
-            ad,       ffdc, dataIface, journal};
+        PEL pel{regEntry,  42,
+                timestamp, phosphor::logging::Entry::Level::Error,
+                ad,        ffdc,
+                dataIface, journal};
 
         // The last section should have been dropped, so same as first TC
         ASSERT_EQ(pel.privateHeader().sectionCount(), pelSectsWithOneUD);
diff --git a/test/openpower-pels/registry_test.cpp b/test/openpower-pels/registry_test.cpp
index 1646a49..ce17e9b 100644
--- a/test/openpower-pels/registry_test.cpp
+++ b/test/openpower-pels/registry_test.cpp
@@ -269,8 +269,8 @@
     auto path = RegistryTest::writeData(registryData);
     Registry registry{path};
 
-    auto entry = registry.lookup("xyz.openbmc_project.Power.Fault",
-                                 LookupType::name);
+    auto entry =
+        registry.lookup("xyz.openbmc_project.Power.Fault", LookupType::name);
     ASSERT_TRUE(entry);
     EXPECT_EQ(entry->name, "xyz.openbmc_project.Power.Fault");
     EXPECT_EQ(entry->subsystem, 0x61);
@@ -407,8 +407,8 @@
     using namespace openpower::pels::message::helper;
 
     // Get it from the JSON
-    auto id = getComponentID(0xBD, 0x4200, R"({"ComponentID":"0x4200"})"_json,
-                             "foo");
+    auto id =
+        getComponentID(0xBD, 0x4200, R"({"ComponentID":"0x4200"})"_json, "foo");
     EXPECT_EQ(id, 0x4200);
 
     // Get it from the reason code on a 0xBD SRC
diff --git a/test/openpower-pels/src_callout_test.cpp b/test/openpower-pels/src_callout_test.cpp
index a03b9b0..4f77bde 100644
--- a/test/openpower-pels/src_callout_test.cpp
+++ b/test/openpower-pels/src_callout_test.cpp
@@ -284,9 +284,9 @@
         Callout callout{CalloutPriority::high, "U99-P5", "1234567", "ABCD",
                         "123456789ABC",        mruList};
 
-        EXPECT_EQ(callout.flags(), Callout::calloutType |
-                                       Callout::fruIdentIncluded |
-                                       Callout::mruIncluded);
+        EXPECT_EQ(callout.flags(),
+                  Callout::calloutType | Callout::fruIdentIncluded |
+                      Callout::mruIncluded);
 
         EXPECT_EQ(callout.priority(), 'H');
         EXPECT_EQ(callout.locationCode(), "U99-P5");
diff --git a/test/openpower-pels/src_test.cpp b/test/openpower-pels/src_test.cpp
index 4a85bee..2fb8770 100644
--- a/test/openpower-pels/src_test.cpp
+++ b/test/openpower-pels/src_test.cpp
@@ -624,9 +624,9 @@
                 "/xyz/openbmc_project/inventory/chassis/motherboard/cpu0", _, _,
                 _))
             .Times(1)
-            .WillOnce(DoAll(SetArgReferee<1>("1234567"),
-                            SetArgReferee<2>("CCCC"),
-                            SetArgReferee<3>("123456789ABC")));
+            .WillOnce(
+                DoAll(SetArgReferee<1>("1234567"), SetArgReferee<2>("CCCC"),
+                      SetArgReferee<3>("123456789ABC")));
 
         EXPECT_CALL(
             dataIface,
@@ -634,9 +634,9 @@
                 "/xyz/openbmc_project/inventory/chassis/motherboard/cpu1", _, _,
                 _))
             .Times(1)
-            .WillOnce(DoAll(SetArgReferee<1>("2345678"),
-                            SetArgReferee<2>("DDDD"),
-                            SetArgReferee<3>("23456789ABCD")));
+            .WillOnce(
+                DoAll(SetArgReferee<1>("2345678"), SetArgReferee<2>("DDDD"),
+                      SetArgReferee<3>("23456789ABCD")));
 
         SRC src{entry, ad, dataIface};
 
@@ -843,30 +843,30 @@
         .Times(3)
         .WillRepeatedly(Return("Ufcs-P1-C15"));
 
-    EXPECT_CALL(
-        dataIface,
-        getHWCalloutFields(
-            "/xyz/openbmc_project/inventory/chassis/motherboard/cpu0", _, _, _))
+    EXPECT_CALL(dataIface,
+                getHWCalloutFields(
+                    "/xyz/openbmc_project/inventory/chassis/motherboard/cpu0",
+                    _, _, _))
         .Times(3)
-        .WillRepeatedly(DoAll(SetArgReferee<1>("1234567"),
-                              SetArgReferee<2>("CCCC"),
-                              SetArgReferee<3>("123456789ABC")));
+        .WillRepeatedly(
+            DoAll(SetArgReferee<1>("1234567"), SetArgReferee<2>("CCCC"),
+                  SetArgReferee<3>("123456789ABC")));
     EXPECT_CALL(
         dataIface,
         getHWCalloutFields("/xyz/openbmc_project/inventory/chassis/motherboard",
                            _, _, _))
         .Times(3)
-        .WillRepeatedly(DoAll(SetArgReferee<1>("7654321"),
-                              SetArgReferee<2>("MMMM"),
-                              SetArgReferee<3>("CBA987654321")));
-    EXPECT_CALL(
-        dataIface,
-        getHWCalloutFields(
-            "/xyz/openbmc_project/inventory/chassis/motherboard/bmc", _, _, _))
+        .WillRepeatedly(
+            DoAll(SetArgReferee<1>("7654321"), SetArgReferee<2>("MMMM"),
+                  SetArgReferee<3>("CBA987654321")));
+    EXPECT_CALL(dataIface,
+                getHWCalloutFields(
+                    "/xyz/openbmc_project/inventory/chassis/motherboard/bmc", _,
+                    _, _))
         .Times(3)
-        .WillRepeatedly(DoAll(SetArgReferee<1>("7123456"),
-                              SetArgReferee<2>("BBBB"),
-                              SetArgReferee<3>("C123456789AB")));
+        .WillRepeatedly(
+            DoAll(SetArgReferee<1>("7123456"), SetArgReferee<2>("BBBB"),
+                  SetArgReferee<3>("C123456789AB")));
 
     // Call this below with different AdditionalData values that
     // result in the same callouts.
@@ -1042,9 +1042,9 @@
             dataIface,
             getHWCalloutFields("/inv/system/chassis/motherboard/bmc", _, _, _))
             .Times(1)
-            .WillOnce(DoAll(SetArgReferee<1>("1234567"),
-                            SetArgReferee<2>("CCCC"),
-                            SetArgReferee<3>("123456789ABC")));
+            .WillOnce(
+                DoAll(SetArgReferee<1>("1234567"), SetArgReferee<2>("CCCC"),
+                      SetArgReferee<3>("123456789ABC")));
     }
     // Callout 1 mock calls
     {
@@ -1055,9 +1055,9 @@
             dataIface,
             getHWCalloutFields("/inv/system/chassis/motherboard/cpu0", _, _, _))
             .Times(1)
-            .WillOnce(DoAll(SetArgReferee<1>("2345678"),
-                            SetArgReferee<2>("DDDD"),
-                            SetArgReferee<3>("23456789ABCD")));
+            .WillOnce(
+                DoAll(SetArgReferee<1>("2345678"), SetArgReferee<2>("DDDD"),
+                      SetArgReferee<3>("23456789ABCD")));
     }
     // Callout 3 mock calls
     {
@@ -1230,9 +1230,9 @@
             dataIface,
             getHWCalloutFields("/inv/system/chassis/motherboard/bmc", _, _, _))
             .Times(1)
-            .WillOnce(DoAll(SetArgReferee<1>("1234567"),
-                            SetArgReferee<2>("CCCC"),
-                            SetArgReferee<3>("123456789ABC")));
+            .WillOnce(
+                DoAll(SetArgReferee<1>("1234567"), SetArgReferee<2>("CCCC"),
+                      SetArgReferee<3>("123456789ABC")));
     }
 
     // Callout 1 mock calls
diff --git a/test/openpower-pels/user_data_test.cpp b/test/openpower-pels/user_data_test.cpp
index 863d36a..9aae466 100644
--- a/test/openpower-pels/user_data_test.cpp
+++ b/test/openpower-pels/user_data_test.cpp
@@ -20,14 +20,14 @@
 
 using namespace openpower::pels;
 
-std::vector<uint8_t> udSectionData{0x55, 0x44, // ID 'UD'
-                                   0x00, 0x10, // Size
-                                   0x01, 0x02, // version, subtype
-                                   0x03, 0x04, // comp ID
+std::vector<uint8_t> udSectionData{
+    0x55, 0x44, // ID 'UD'
+    0x00, 0x10, // Size
+    0x01, 0x02, // version, subtype
+    0x03, 0x04, // comp ID
 
-                                   // Data
-                                   0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-                                   0x18};
+    // Data
+    0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18};
 
 TEST(UserDataTest, UnflattenFlattenTest)
 {