diff --git a/thresholds.hpp b/thresholds.hpp
index 360851c..1aa8e37 100644
--- a/thresholds.hpp
+++ b/thresholds.hpp
@@ -2,11 +2,13 @@
 
 #include "dbusUtils.hpp"
 
+#include <phosphor-logging/commit.hpp>
 #include <xyz/openbmc_project/Sensor/Threshold/Critical/server.hpp>
 #include <xyz/openbmc_project/Sensor/Threshold/HardShutdown/server.hpp>
 #include <xyz/openbmc_project/Sensor/Threshold/PerformanceLoss/server.hpp>
 #include <xyz/openbmc_project/Sensor/Threshold/SoftShutdown/server.hpp>
 #include <xyz/openbmc_project/Sensor/Threshold/Warning/server.hpp>
+#include <xyz/openbmc_project/Sensor/Threshold/event.hpp>
 #include <xyz/openbmc_project/Sensor/Value/server.hpp>
 
 const constexpr char* entityManagerBusName =
@@ -54,11 +56,52 @@
     }
 };
 
+template <typename error>
+auto tryCommit(const std::string& objPath, double value, Unit unit,
+               double thresholdValue)
+    -> std::optional<sdbusplus::message::object_path>
+{
+    try
+    {
+        return lg2::commit(
+            error("SENSOR_NAME", objPath, "READING_VALUE", value, "UNITS", unit,
+                  "THRESHOLD_VALUE", thresholdValue));
+    }
+    catch (std::exception&)
+    {
+        lg2::error(
+            "Failed creating a threshold log entry for {SENSOR} with value {VALUE}",
+            "SENSOR", objPath, "VALUE", value);
+        return std::nullopt;
+    }
+}
+
+static inline void tryResolve(
+    std::optional<sdbusplus::message::object_path>& log)
+{
+    if (log)
+    {
+        try
+        {
+            lg2::resolve(*log);
+        }
+        catch (std::exception&)
+        {
+            lg2::error("Failed to resolve: {LOG}", "LOG", *log);
+        }
+        log.reset();
+    }
+}
+
 template <>
 struct Threshold<WarningObject> : public WarningObject, public Hysteresis
 {
     static constexpr auto name = "Warning";
     using WarningObject::WarningObject;
+    using ReadingAboveUpperWarningThreshold = sdbusplus::error::xyz::
+        openbmc_project::sensor::Threshold::ReadingAboveUpperWarningThreshold;
+    using ReadingBelowLowerWarningThreshold = sdbusplus::error::xyz::
+        openbmc_project::sensor::Threshold::ReadingBelowLowerWarningThreshold;
     /** @brief sdbusplus bus client connection. */
     sdbusplus::bus_t& bus;
     std::string objPath;
@@ -70,6 +113,8 @@
     std::string entityPath;
     std::string entityInterfaceHigh;
     std::string entityInterfaceLow;
+    std::optional<sdbusplus::message::object_path> assertedHighLog;
+    std::optional<sdbusplus::message::object_path> assertedLowLog;
 
     /** @brief Constructor to put object onto bus at a dbus path.
      *  @param[in] bus - Bus to attach to.
@@ -102,27 +147,33 @@
         return warningAlarmLow(std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
-    auto alarmHighSignalAsserted(Args... args)
+    template <typename V>
+    auto alarmHighSignalAsserted(V value)
     {
-        return warningHighAlarmAsserted(std::forward<Args>(args)...);
+        assertedHighLog = tryCommit<ReadingAboveUpperWarningThreshold>(
+            objPath, value, units, high());
+        return warningHighAlarmAsserted(value);
     }
 
     template <typename... Args>
     auto alarmHighSignalDeasserted(Args... args)
     {
+        tryResolve(assertedHighLog);
         return warningHighAlarmDeasserted(std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
-    auto alarmLowSignalAsserted(Args... args)
+    template <typename V>
+    auto alarmLowSignalAsserted(V value)
     {
-        return warningLowAlarmAsserted(std::forward<Args>(args)...);
+        assertedLowLog = tryCommit<ReadingBelowLowerWarningThreshold>(
+            objPath, value, units, low());
+        return warningLowAlarmAsserted(value);
     }
 
     template <typename... Args>
     auto alarmLowSignalDeasserted(Args... args)
     {
+        tryResolve(assertedLowLog);
         return warningLowAlarmDeasserted(std::forward<Args>(args)...);
     }
 
@@ -190,8 +241,14 @@
     std::string entityPath;
     std::string entityInterfaceHigh;
     std::string entityInterfaceLow;
+    std::optional<sdbusplus::message::object_path> assertedHighLog;
+    std::optional<sdbusplus::message::object_path> assertedLowLog;
 
     using CriticalObject::CriticalObject;
+    using ReadingAboveUpperCriticalThreshold = sdbusplus::error::xyz::
+        openbmc_project::sensor::Threshold::ReadingAboveUpperCriticalThreshold;
+    using ReadingBelowLowerCriticalThreshold = sdbusplus::error::xyz::
+        openbmc_project::sensor::Threshold::ReadingBelowLowerCriticalThreshold;
 
     /** @brief Constructor to put object onto bus at a dbus path.
      *  @param[in] bus - Bus to attach to.
@@ -224,27 +281,33 @@
         return criticalAlarmLow(std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
-    auto alarmHighSignalAsserted(Args... args)
+    template <typename V>
+    auto alarmHighSignalAsserted(V value)
     {
-        return criticalHighAlarmAsserted(std::forward<Args>(args)...);
+        assertedHighLog = tryCommit<ReadingAboveUpperCriticalThreshold>(
+            objPath, value, units, high());
+        return criticalHighAlarmAsserted(value);
     }
 
     template <typename... Args>
     auto alarmHighSignalDeasserted(Args... args)
     {
+        tryResolve(assertedHighLog);
         return criticalHighAlarmDeasserted(std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
-    auto alarmLowSignalAsserted(Args... args)
+    template <typename V>
+    auto alarmLowSignalAsserted(V value)
     {
-        return criticalLowAlarmAsserted(std::forward<Args>(args)...);
+        assertedLowLog = tryCommit<ReadingBelowLowerCriticalThreshold>(
+            objPath, value, units, low());
+        return criticalLowAlarmAsserted(value);
     }
 
     template <typename... Args>
     auto alarmLowSignalDeasserted(Args... args)
     {
+        tryResolve(assertedLowLog);
         return criticalLowAlarmDeasserted(std::forward<Args>(args)...);
     }
 
@@ -301,12 +364,22 @@
     public Hysteresis
 {
     static constexpr auto name = "SoftShutdown";
-    using SoftShutdownObject::SoftShutdownObject;
+
     /** @brief sdbusplus bus client connection. */
     sdbusplus::bus_t& bus;
     std::string objPath;
     Unit units;
 
+    using SoftShutdownObject::SoftShutdownObject;
+    using ReadingAboveUpperSoftShutdownThreshold =
+        sdbusplus::error::xyz::openbmc_project::sensor::Threshold::
+            ReadingAboveUpperSoftShutdownThreshold;
+    using ReadingBelowLowerSoftShutdownThreshold =
+        sdbusplus::error::xyz::openbmc_project::sensor::Threshold::
+            ReadingBelowLowerSoftShutdownThreshold;
+    std::optional<sdbusplus::message::object_path> assertedHighLog;
+    std::optional<sdbusplus::message::object_path> assertedLowLog;
+
     /** @brief Constructor to put object onto bus at a dbus path.
      *  @param[in] bus - Bus to attach to.
      *  @param[in] path - Path to attach at.
@@ -338,27 +411,33 @@
         return softShutdownAlarmLow(std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
-    auto alarmHighSignalAsserted(Args... args)
+    template <typename V>
+    auto alarmHighSignalAsserted(V value)
     {
-        return softShutdownHighAlarmAsserted(std::forward<Args>(args)...);
+        assertedHighLog = tryCommit<ReadingAboveUpperSoftShutdownThreshold>(
+            objPath, value, units, high());
+        return softShutdownHighAlarmAsserted(value);
     }
 
     template <typename... Args>
     auto alarmHighSignalDeasserted(Args... args)
     {
+        tryResolve(assertedHighLog);
         return softShutdownHighAlarmDeasserted(std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
-    auto alarmLowSignalAsserted(Args... args)
+    template <typename V>
+    auto alarmLowSignalAsserted(V value)
     {
-        return softShutdownLowAlarmAsserted(std::forward<Args>(args)...);
+        assertedLowLog = tryCommit<ReadingBelowLowerSoftShutdownThreshold>(
+            objPath, value, units, low());
+        return softShutdownLowAlarmAsserted(value);
     }
 
     template <typename... Args>
     auto alarmLowSignalDeasserted(Args... args)
     {
+        tryResolve(assertedLowLog);
         return softShutdownLowAlarmDeasserted(std::forward<Args>(args)...);
     }
 };
@@ -369,12 +448,21 @@
     public Hysteresis
 {
     static constexpr auto name = "HardShutdown";
+
     /** @brief sdbusplus bus client connection. */
     sdbusplus::bus_t& bus;
     std::string objPath;
     Unit units;
 
     using HardShutdownObject::HardShutdownObject;
+    using ReadingAboveUpperHardShutdownThreshold =
+        sdbusplus::error::xyz::openbmc_project::sensor::Threshold::
+            ReadingAboveUpperHardShutdownThreshold;
+    using ReadingBelowLowerHardShutdownThreshold =
+        sdbusplus::error::xyz::openbmc_project::sensor::Threshold::
+            ReadingBelowLowerHardShutdownThreshold;
+    std::optional<sdbusplus::message::object_path> assertedHighLog;
+    std::optional<sdbusplus::message::object_path> assertedLowLog;
 
     /** @brief Constructor to put object onto bus at a dbus path.
      *  @param[in] bus - Bus to attach to.
@@ -407,27 +495,33 @@
         return hardShutdownAlarmLow(std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
-    auto alarmHighSignalAsserted(Args... args)
+    template <typename V>
+    auto alarmHighSignalAsserted(V value)
     {
-        return hardShutdownHighAlarmAsserted(std::forward<Args>(args)...);
+        assertedHighLog = tryCommit<ReadingAboveUpperHardShutdownThreshold>(
+            objPath, value, units, high());
+        return hardShutdownHighAlarmAsserted(value);
     }
 
     template <typename... Args>
     auto alarmHighSignalDeasserted(Args... args)
     {
+        tryResolve(assertedHighLog);
         return hardShutdownHighAlarmDeasserted(std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
-    auto alarmLowSignalAsserted(Args... args)
+    template <typename V>
+    auto alarmLowSignalAsserted(V value)
     {
-        return hardShutdownLowAlarmAsserted(std::forward<Args>(args)...);
+        assertedLowLog = tryCommit<ReadingBelowLowerHardShutdownThreshold>(
+            objPath, value, units, low());
+        return hardShutdownLowAlarmAsserted(value);
     }
 
     template <typename... Args>
     auto alarmLowSignalDeasserted(Args... args)
     {
+        tryResolve(assertedLowLog);
         return hardShutdownLowAlarmDeasserted(std::forward<Args>(args)...);
     }
 };
@@ -444,8 +538,16 @@
     Unit units;
 
     using PerformanceLossObject::PerformanceLossObject;
+    using ReadingAboveUpperPerformanceLossThreshold =
+        sdbusplus::error::xyz::openbmc_project::sensor::Threshold::
+            ReadingAboveUpperPerformanceLossThreshold;
+    using ReadingBelowLowerPerformanceLossThreshold =
+        sdbusplus::error::xyz::openbmc_project::sensor::Threshold::
+            ReadingBelowLowerPerformanceLossThreshold;
     double performanceLossHighHysteresis;
     double performanceLossLowHysteresis;
+    std::optional<sdbusplus::message::object_path> assertedHighLog;
+    std::optional<sdbusplus::message::object_path> assertedLowLog;
 
     /** @brief Constructor to put object onto bus at a dbus path.
      *  @param[in] bus - Bus to attach to.
@@ -478,27 +580,33 @@
         return performanceLossAlarmLow(std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
-    auto alarmHighSignalAsserted(Args... args)
+    template <typename V>
+    auto alarmHighSignalAsserted(V value)
     {
-        return performanceLossHighAlarmAsserted(std::forward<Args>(args)...);
+        assertedHighLog = tryCommit<ReadingAboveUpperPerformanceLossThreshold>(
+            objPath, value, units, high());
+        return performanceLossHighAlarmAsserted(value);
     }
 
     template <typename... Args>
     auto alarmHighSignalDeasserted(Args... args)
     {
+        tryResolve(assertedHighLog);
         return performanceLossHighAlarmDeasserted(std::forward<Args>(args)...);
     }
 
-    template <typename... Args>
-    auto alarmLowSignalAsserted(Args... args)
+    template <typename V>
+    auto alarmLowSignalAsserted(V value)
     {
-        return performanceLossLowAlarmAsserted(std::forward<Args>(args)...);
+        assertedLowLog = tryCommit<ReadingBelowLowerPerformanceLossThreshold>(
+            objPath, value, units, low());
+        return performanceLossLowAlarmAsserted(value);
     }
 
     template <typename... Args>
     auto alarmLowSignalDeasserted(Args... args)
     {
+        tryResolve(assertedLowLog);
         return performanceLossLowAlarmDeasserted(std::forward<Args>(args)...);
     }
 };