diff --git a/src/discrete_threshold.cpp b/src/discrete_threshold.cpp
index 1bb250f..ba915b1 100644
--- a/src/discrete_threshold.cpp
+++ b/src/discrete_threshold.cpp
@@ -5,15 +5,18 @@
 #include <phosphor-logging/log.hpp>
 
 DiscreteThreshold::DiscreteThreshold(
-    boost::asio::io_context& ioc, Sensors sensorsIn,
+    boost::asio::io_context& ioc, const std::string& triggerIdIn,
+    Sensors sensorsIn,
     std::vector<std::unique_ptr<interfaces::TriggerAction>> actionsIn,
     Milliseconds dwellTimeIn, const std::string& thresholdValueIn,
-    const std::string& nameIn, const discrete::Severity severityIn) :
+    const std::string& nameIn, const discrete::Severity severityIn,
+    std::unique_ptr<interfaces::Clock> clockIn) :
     ioc(ioc),
-    actions(std::move(actionsIn)), dwellTime(dwellTimeIn),
-    thresholdValue(thresholdValueIn),
-    numericThresholdValue(utils::stodStrict(thresholdValue)), name(nameIn),
-    severity(severityIn)
+    triggerId(triggerIdIn), actions(std::move(actionsIn)),
+    dwellTime(dwellTimeIn), thresholdValue(thresholdValueIn),
+    numericThresholdValue(utils::stodStrict(thresholdValue)),
+    severity(severityIn), name(getNonEmptyName(nameIn)),
+    clock(std::move(clockIn))
 {
     for (const auto& sensor : sensorsIn)
     {
@@ -56,12 +59,12 @@
     }
     else if (value == numericThresholdValue)
     {
-        startTimer(details, timestamp, value);
+        startTimer(details, value);
     }
 }
 
 void DiscreteThreshold::startTimer(DiscreteThreshold::ThresholdDetail& details,
-                                   Milliseconds timestamp, double value)
+                                   double value)
 {
     const auto& sensorName = details.sensorName;
     auto& dwell = details.dwell;
@@ -69,13 +72,13 @@
 
     if (dwellTime == Milliseconds::zero())
     {
-        commit(sensorName, timestamp, value);
+        commit(sensorName, value);
     }
     else
     {
         dwell = true;
         timer.expires_after(dwellTime);
-        timer.async_wait([this, &sensorName, &dwell, timestamp,
+        timer.async_wait([this, &sensorName, &dwell,
                           value](const boost::system::error_code ec) {
             if (ec)
             {
@@ -83,18 +86,19 @@
                     "Timer has been canceled");
                 return;
             }
-            commit(sensorName, timestamp, value);
+            commit(sensorName, value);
             dwell = false;
         });
     }
 }
 
-void DiscreteThreshold::commit(const std::string& sensorName,
-                               Milliseconds timestamp, double value)
+void DiscreteThreshold::commit(const std::string& sensorName, double value)
 {
+    Milliseconds timestamp = clock->systemTimestamp();
     for (const auto& action : actions)
     {
-        action->commit(sensorName, timestamp, value);
+        action->commit(triggerId, std::cref(name), sensorName, timestamp,
+                       thresholdValue);
     }
 }
 
@@ -103,3 +107,12 @@
     return discrete::LabeledThresholdParam(name, severity, dwellTime.count(),
                                            thresholdValue);
 }
+
+std::string DiscreteThreshold::getNonEmptyName(const std::string& nameIn) const
+{
+    if (nameIn.empty())
+    {
+        return discrete::severityToString(severity) + " condition";
+    }
+    return nameIn;
+}
diff --git a/src/discrete_threshold.hpp b/src/discrete_threshold.hpp
index 545a980..a471027 100644
--- a/src/discrete_threshold.hpp
+++ b/src/discrete_threshold.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "interfaces/clock.hpp"
 #include "interfaces/sensor.hpp"
 #include "interfaces/sensor_listener.hpp"
 #include "interfaces/threshold.hpp"
@@ -22,10 +23,12 @@
 {
   public:
     DiscreteThreshold(
-        boost::asio::io_context& ioc, Sensors sensors,
+        boost::asio::io_context& ioc, const std::string& triggerId,
+        Sensors sensors,
         std::vector<std::unique_ptr<interfaces::TriggerAction>> actions,
         Milliseconds dwellTime, const std::string& thresholdValue,
-        const std::string& name, const discrete::Severity severity);
+        const std::string& name, const discrete::Severity severity,
+        std::unique_ptr<interfaces::Clock> clock);
     DiscreteThreshold(const DiscreteThreshold&) = delete;
     DiscreteThreshold(DiscreteThreshold&&) = delete;
 
@@ -36,13 +39,15 @@
 
   private:
     boost::asio::io_context& ioc;
+    const std::string& triggerId;
     const std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
     const Milliseconds dwellTime;
     const std::string thresholdValue;
     const double numericThresholdValue;
-    const std::string name;
     const discrete::Severity severity;
+    const std::string name;
     bool initialized = false;
+    std::unique_ptr<interfaces::Clock> clock;
 
     struct ThresholdDetail
     {
@@ -63,8 +68,9 @@
 
     friend ThresholdOperations;
 
-    void startTimer(ThresholdDetail&, Milliseconds, double);
-    void commit(const std::string&, Milliseconds, double);
+    void startTimer(ThresholdDetail&, double);
+    void commit(const std::string&, double);
     ThresholdDetail& getDetails(const interfaces::Sensor& sensor);
     std::shared_ptr<ThresholdDetail> makeDetails(const std::string& sensorName);
+    std::string getNonEmptyName(const std::string& nameIn) const;
 };
diff --git a/src/interfaces/trigger_action.hpp b/src/interfaces/trigger_action.hpp
index 437a79f..7e0babd 100644
--- a/src/interfaces/trigger_action.hpp
+++ b/src/interfaces/trigger_action.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "types/duration_types.hpp"
+#include "types/trigger_types.hpp"
 
 #include <cstdint>
 #include <string>
@@ -13,7 +14,10 @@
   public:
     virtual ~TriggerAction() = default;
 
-    virtual void commit(const std::string& id, Milliseconds timestamp,
-                        double value) = 0;
+    virtual void commit(const std::string& triggerId,
+                        const ThresholdName thresholdName,
+                        const std::string& sensorId,
+                        const Milliseconds timestamp,
+                        const TriggerValue value) = 0;
 };
 } // namespace interfaces
diff --git a/src/interfaces/trigger_factory.hpp b/src/interfaces/trigger_factory.hpp
index 0e7ac7f..947af43 100644
--- a/src/interfaces/trigger_factory.hpp
+++ b/src/interfaces/trigger_factory.hpp
@@ -40,6 +40,7 @@
 
     virtual void updateThresholds(
         std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+        const std::string& triggerId,
         const std::vector<::TriggerAction>& triggerActions,
         const std::shared_ptr<std::vector<std::string>>& reportIds,
         const Sensors& sensors,
diff --git a/src/numeric_threshold.cpp b/src/numeric_threshold.cpp
index cb6dbdd..9bda509 100644
--- a/src/numeric_threshold.cpp
+++ b/src/numeric_threshold.cpp
@@ -3,13 +3,16 @@
 #include <phosphor-logging/log.hpp>
 
 NumericThreshold::NumericThreshold(
-    boost::asio::io_context& ioc, Sensors sensorsIn,
+    boost::asio::io_context& ioc, const std::string& triggerIdIn,
+    Sensors sensorsIn,
     std::vector<std::unique_ptr<interfaces::TriggerAction>> actionsIn,
     Milliseconds dwellTimeIn, numeric::Direction directionIn,
-    double thresholdValueIn, numeric::Type typeIn) :
+    double thresholdValueIn, numeric::Type typeIn,
+    std::unique_ptr<interfaces::Clock> clockIn) :
     ioc(ioc),
-    actions(std::move(actionsIn)), dwellTime(dwellTimeIn),
-    direction(directionIn), thresholdValue(thresholdValueIn), type(typeIn)
+    triggerId(triggerIdIn), actions(std::move(actionsIn)),
+    dwellTime(dwellTimeIn), direction(directionIn),
+    thresholdValue(thresholdValueIn), type(typeIn), clock(std::move(clockIn))
 {
     for (const auto& sensor : sensorsIn)
     {
@@ -57,14 +60,14 @@
         (direction == numeric::Direction::increasing && increasing) ||
         (direction == numeric::Direction::either && (increasing || decreasing)))
     {
-        startTimer(details, timestamp, value);
+        startTimer(details, value);
     }
 
     prevValue = value;
 }
 
 void NumericThreshold::startTimer(NumericThreshold::ThresholdDetail& details,
-                                  Milliseconds timestamp, double value)
+                                  double value)
 {
     const auto& sensorName = details.sensorName;
     auto& dwell = details.dwell;
@@ -72,13 +75,13 @@
 
     if (dwellTime == Milliseconds::zero())
     {
-        commit(sensorName, timestamp, value);
+        commit(sensorName, value);
     }
     else
     {
         dwell = true;
         timer.expires_after(dwellTime);
-        timer.async_wait([this, &sensorName, &dwell, timestamp,
+        timer.async_wait([this, &sensorName, &dwell,
                           value](const boost::system::error_code ec) {
             if (ec)
             {
@@ -86,18 +89,18 @@
                     "Timer has been canceled");
                 return;
             }
-            commit(sensorName, timestamp, value);
+            commit(sensorName, value);
             dwell = false;
         });
     }
 }
 
-void NumericThreshold::commit(const std::string& sensorName,
-                              Milliseconds timestamp, double value)
+void NumericThreshold::commit(const std::string& sensorName, double value)
 {
+    Milliseconds timestamp = clock->systemTimestamp();
     for (const auto& action : actions)
     {
-        action->commit(sensorName, timestamp, value);
+        action->commit(triggerId, std::nullopt, sensorName, timestamp, value);
     }
 }
 
diff --git a/src/numeric_threshold.hpp b/src/numeric_threshold.hpp
index ecf3d6a..d70729a 100644
--- a/src/numeric_threshold.hpp
+++ b/src/numeric_threshold.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "interfaces/clock.hpp"
 #include "interfaces/sensor.hpp"
 #include "interfaces/sensor_listener.hpp"
 #include "interfaces/threshold.hpp"
@@ -22,10 +23,12 @@
 {
   public:
     NumericThreshold(
-        boost::asio::io_context& ioc, Sensors sensors,
+        boost::asio::io_context& ioc, const std::string& triggerId,
+        Sensors sensors,
         std::vector<std::unique_ptr<interfaces::TriggerAction>> actions,
         Milliseconds dwellTime, numeric::Direction direction,
-        double thresholdValue, numeric::Type type);
+        double thresholdValue, numeric::Type type,
+        std::unique_ptr<interfaces::Clock> clock);
     ~NumericThreshold()
     {}
 
@@ -36,12 +39,14 @@
 
   private:
     boost::asio::io_context& ioc;
+    const std::string& triggerId;
     const std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
     const Milliseconds dwellTime;
     const numeric::Direction direction;
     const double thresholdValue;
     const numeric::Type type;
     bool initialized = false;
+    std::unique_ptr<interfaces::Clock> clock;
 
     struct ThresholdDetail
     {
@@ -63,8 +68,8 @@
 
     friend ThresholdOperations;
 
-    void startTimer(ThresholdDetail&, Milliseconds, double);
-    void commit(const std::string&, Milliseconds, double);
+    void startTimer(ThresholdDetail&, double);
+    void commit(const std::string&, double);
     ThresholdDetail& getDetails(const interfaces::Sensor& sensor);
     std::shared_ptr<ThresholdDetail> makeDetails(const std::string& sensorName);
 };
diff --git a/src/on_change_threshold.cpp b/src/on_change_threshold.cpp
index eea8978..206deb2 100644
--- a/src/on_change_threshold.cpp
+++ b/src/on_change_threshold.cpp
@@ -3,10 +3,12 @@
 #include <phosphor-logging/log.hpp>
 
 OnChangeThreshold::OnChangeThreshold(
-    Sensors sensorsIn,
-    std::vector<std::unique_ptr<interfaces::TriggerAction>> actionsIn) :
-    sensors(std::move(sensorsIn)),
-    actions(std::move(actionsIn))
+    const std::string& triggerIdIn, Sensors sensorsIn,
+    std::vector<std::unique_ptr<interfaces::TriggerAction>> actionsIn,
+    std::unique_ptr<interfaces::Clock> clockIn) :
+    triggerId(triggerIdIn),
+    sensors(std::move(sensorsIn)), actions(std::move(actionsIn)),
+    clock(std::move(clockIn))
 {}
 
 void OnChangeThreshold::initialize()
@@ -59,15 +61,15 @@
         return;
     }
 
-    commit(sensor.getName(), timestamp, value);
+    commit(sensor.getName(), value);
 }
 
-void OnChangeThreshold::commit(const std::string& sensorName,
-                               Milliseconds timestamp, double value)
+void OnChangeThreshold::commit(const std::string& sensorName, double value)
 {
+    Milliseconds timestamp = clock->systemTimestamp();
     for (const auto& action : actions)
     {
-        action->commit(sensorName, timestamp, value);
+        action->commit(triggerId, std::nullopt, sensorName, timestamp, value);
     }
 }
 
diff --git a/src/on_change_threshold.hpp b/src/on_change_threshold.hpp
index 1d4a4d0..a19a86f 100644
--- a/src/on_change_threshold.hpp
+++ b/src/on_change_threshold.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "interfaces/clock.hpp"
 #include "interfaces/sensor.hpp"
 #include "interfaces/sensor_listener.hpp"
 #include "interfaces/threshold.hpp"
@@ -19,8 +20,9 @@
 {
   public:
     OnChangeThreshold(
-        Sensors sensors,
-        std::vector<std::unique_ptr<interfaces::TriggerAction>> actions);
+        const std::string& triggerId, Sensors sensors,
+        std::vector<std::unique_ptr<interfaces::TriggerAction>> actions,
+        std::unique_ptr<interfaces::Clock> clock);
     ~OnChangeThreshold()
     {}
 
@@ -30,10 +32,12 @@
     void updateSensors(Sensors newSensors) override;
 
   private:
+    const std::string& triggerId;
     Sensors sensors;
     const std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
     bool initialized = false;
     bool isFirstReading = true;
+    std::unique_ptr<interfaces::Clock> clock;
 
-    void commit(const std::string&, Milliseconds, double);
+    void commit(const std::string&, double);
 };
diff --git a/src/trigger.cpp b/src/trigger.cpp
index 485f2f9..ab48281 100644
--- a/src/trigger.cpp
+++ b/src/trigger.cpp
@@ -14,18 +14,18 @@
 Trigger::Trigger(
     boost::asio::io_context& ioc,
     const std::shared_ptr<sdbusplus::asio::object_server>& objServer,
-    const std::string& idIn, const std::string& nameIn,
+    TriggerId&& idIn, const std::string& nameIn,
     const std::vector<TriggerAction>& triggerActionsIn,
     const std::shared_ptr<std::vector<std::string>> reportIdsIn,
     std::vector<std::shared_ptr<interfaces::Threshold>>&& thresholdsIn,
     interfaces::TriggerManager& triggerManager,
     interfaces::JsonStorage& triggerStorageIn,
     const interfaces::TriggerFactory& triggerFactory, Sensors sensorsIn) :
-    id(idIn),
+    id(std::move(idIn)),
     name(nameIn), triggerActions(std::move(triggerActionsIn)),
-    path(triggerDir + id), reportIds(std::move(reportIdsIn)),
+    path(triggerDir + *id), reportIds(std::move(reportIdsIn)),
     thresholds(std::move(thresholdsIn)),
-    fileName(std::to_string(std::hash<std::string>{}(id))),
+    fileName(std::to_string(std::hash<std::string>{}(*id))),
     triggerStorage(triggerStorageIn), sensors(std::move(sensorsIn)),
     messanger(ioc)
 {
@@ -37,7 +37,7 @@
                     triggerStorage.remove(fileName);
                 }
                 messanger.send(messages::TriggerPresenceChangedInd{
-                    messages::Presence::Removed, id, {}});
+                    messages::Presence::Removed, *id, {}});
                 boost::asio::post(ioc, [this, &triggerManager] {
                     triggerManager.removeTrigger(this);
                 });
@@ -74,9 +74,9 @@
                 [this, &triggerFactory](auto newVal, auto& oldVal) {
                     auto newThresholdParams = std::visit(
                         utils::ToLabeledThresholdParamConversion(), newVal);
-                    triggerFactory.updateThresholds(thresholds, triggerActions,
-                                                    reportIds, sensors,
-                                                    newThresholdParams);
+                    triggerFactory.updateThresholds(
+                        thresholds, *id, triggerActions, reportIds, sensors,
+                        newThresholdParams);
                     oldVal = std::move(newVal);
                     return 1;
                 },
@@ -110,7 +110,7 @@
                     TriggerManager::verifyReportIds(newVal);
                     *reportIds = newVal;
                     messanger.send(messages::TriggerPresenceChangedInd{
-                        messages::Presence::Exist, id, *reportIds});
+                        messages::Presence::Exist, *id, *reportIds});
                     oldVal = std::move(newVal);
                     return 1;
                 },
@@ -147,12 +147,12 @@
         [this](const auto& msg) {
             if (utils::contains(*reportIds, msg.reportId))
             {
-                messanger.send(messages::CollectTriggerIdResp{id});
+                messanger.send(messages::CollectTriggerIdResp{*id});
             }
         });
 
     messanger.send(messages::TriggerPresenceChangedInd{
-        messages::Presence::Exist, id, *reportIds});
+        messages::Presence::Exist, *id, *reportIds});
 }
 
 bool Trigger::storeConfiguration() const
@@ -166,7 +166,7 @@
                        fromLabeledThresholdParam(getLabeledThresholds()));
 
         data["Version"] = triggerVersion;
-        data["Id"] = id;
+        data["Id"] = *id;
         data["Name"] = name;
         data["ThresholdParamsDiscriminator"] = labeledThresholdParams.index();
         data["TriggerActions"] =
diff --git a/src/trigger.hpp b/src/trigger.hpp
index 6bd2556..832a277 100644
--- a/src/trigger.hpp
+++ b/src/trigger.hpp
@@ -18,7 +18,7 @@
   public:
     Trigger(boost::asio::io_context& ioc,
             const std::shared_ptr<sdbusplus::asio::object_server>& objServer,
-            const std::string& id, const std::string& name,
+            TriggerId&& id, const std::string& name,
             const std::vector<TriggerAction>& triggerActions,
             const std::shared_ptr<std::vector<std::string>> reportIds,
             std::vector<std::shared_ptr<interfaces::Threshold>>&& thresholds,
@@ -34,7 +34,7 @@
 
     std::string getId() const override
     {
-        return id;
+        return *id;
     }
 
     std::string getPath() const override
@@ -49,7 +49,7 @@
     std::vector<LabeledThresholdParam> getLabeledThresholds() const;
     bool isDiscreate() const;
 
-    std::string id;
+    const TriggerId id;
     std::string name;
     std::vector<TriggerAction> triggerActions;
     std::string path;
@@ -71,5 +71,5 @@
         "/xyz/openbmc_project/Telemetry/Triggers/";
     static constexpr const char* deleteIfaceName =
         "xyz.openbmc_project.Object.Delete";
-    static constexpr size_t triggerVersion = 1;
+    static constexpr size_t triggerVersion = 2;
 };
diff --git a/src/trigger_actions.cpp b/src/trigger_actions.cpp
index c840422..75aab50 100644
--- a/src/trigger_actions.cpp
+++ b/src/trigger_actions.cpp
@@ -2,11 +2,14 @@
 
 #include "messages/update_report_ind.hpp"
 #include "types/trigger_types.hpp"
+#include "utils/clock.hpp"
 #include "utils/messanger.hpp"
 
 #include <phosphor-logging/log.hpp>
 
 #include <ctime>
+#include <iomanip>
+#include <sstream>
 
 namespace action
 {
@@ -15,15 +18,12 @@
 {
 std::string timestampToString(Milliseconds timestamp)
 {
-    std::time_t t = static_cast<time_t>(timestamp.count());
-    std::array<char, sizeof("YYYY-MM-DDThh:mm:ssZ")> buf = {};
-    size_t size =
-        std::strftime(buf.data(), buf.size(), "%FT%TZ", std::gmtime(&t));
-    if (size == 0)
-    {
-        throw std::runtime_error("Failed to parse timestamp to string");
-    }
-    return std::string(buf.data(), size);
+    std::time_t t = static_cast<time_t>(
+        std::chrono::duration_cast<std::chrono::seconds>(timestamp).count());
+    std::stringstream ss;
+    ss << std::put_time(std::gmtime(&t), "%FT%T.") << std::setw(3)
+       << std::setfill('0') << timestamp.count() % 1000 << 'Z';
+    return ss.str();
 }
 } // namespace
 
@@ -43,44 +43,60 @@
     throw std::runtime_error("Invalid value");
 }
 
-void LogToJournal::commit(const std::string& sensorName, Milliseconds timestamp,
-                          double value)
+void LogToJournal::commit(const std::string& triggerId,
+                          const ThresholdName thresholdNameInIn,
+                          const std::string& sensorName,
+                          const Milliseconds timestamp,
+                          const TriggerValue triggerValue)
 {
-    std::string msg = ::numeric::typeToString(type) +
-                      " numeric threshold condition is met on sensor " +
-                      sensorName + ", recorded value " + std::to_string(value) +
-                      ", timestamp " + timestampToString(timestamp) +
-                      ", direction " +
-                      std::string(getDirection(value, threshold));
+    double value = std::get<double>(triggerValue);
+    std::string thresholdName = ::numeric::typeToString(type);
+    auto direction = getDirection(value, threshold);
+
+    std::string msg = "Numeric threshold '" + thresholdName + "' of trigger '" +
+                      triggerId + "' is crossed on sensor " + sensorName +
+                      ", recorded value: " + std::to_string(value) +
+                      ", crossing direction: " + direction +
+                      ", timestamp: " + timestampToString(timestamp);
 
     phosphor::logging::log<phosphor::logging::level::INFO>(msg.c_str());
 }
 
-const char* LogToRedfish::getMessageId() const
+const char* LogToRedfishEventLog::getRedfishMessageId() const
 {
     switch (type)
     {
         case ::numeric::Type::upperCritical:
-            return "OpenBMC.0.1.0.NumericThresholdUpperCritical";
+            return redfish_message_ids::TriggerNumericCritical;
         case ::numeric::Type::lowerCritical:
-            return "OpenBMC.0.1.0.NumericThresholdLowerCritical";
+            return redfish_message_ids::TriggerNumericCritical;
         case ::numeric::Type::upperWarning:
-            return "OpenBMC.0.1.0.NumericThresholdUpperWarning";
+            return redfish_message_ids::TriggerNumericWarning;
         case ::numeric::Type::lowerWarning:
-            return "OpenBMC.0.1.0.NumericThresholdLowerWarning";
+            return redfish_message_ids::TriggerNumericWarning;
     }
     throw std::runtime_error("Invalid type");
 }
 
-void LogToRedfish::commit(const std::string& sensorName, Milliseconds timestamp,
-                          double value)
+void LogToRedfishEventLog::commit(const std::string& triggerId,
+                                  const ThresholdName thresholdNameInIn,
+                                  const std::string& sensorName,
+                                  const Milliseconds timestamp,
+                                  const TriggerValue triggerValue)
 {
+    double value = std::get<double>(triggerValue);
+    std::string thresholdName = ::numeric::typeToString(type);
+    auto direction = getDirection(value, threshold);
+    auto timestampStr = timestampToString(timestamp);
+
     phosphor::logging::log<phosphor::logging::level::INFO>(
-        "Threshold value is exceeded",
-        phosphor::logging::entry("REDFISH_MESSAGE_ID=%s", getMessageId()),
-        phosphor::logging::entry("REDFISH_MESSAGE_ARGS=%s,%f,%llu,%s",
-                                 sensorName.c_str(), value, timestamp.count(),
-                                 getDirection(value, threshold)));
+        "Logging numeric trigger action to Redfish Event Log.",
+        phosphor::logging::entry("REDFISH_MESSAGE_ID=%s",
+                                 getRedfishMessageId()),
+        phosphor::logging::entry("REDFISH_MESSAGE_ARGS=%s,%s,%s,%f,%s,%s",
+                                 thresholdName.c_str(), triggerId.c_str(),
+                                 sensorName.c_str(), value, direction,
+                                 timestampStr.c_str()));
 }
 
 void fillActions(
@@ -94,16 +110,16 @@
     {
         switch (actionType)
         {
-            case TriggerAction::LogToLogService:
+            case TriggerAction::LogToJournal:
             {
                 actionsIf.emplace_back(
                     std::make_unique<LogToJournal>(type, thresholdValue));
                 break;
             }
-            case TriggerAction::RedfishEvent:
+            case TriggerAction::LogToRedfishEventLog:
             {
-                actionsIf.emplace_back(
-                    std::make_unique<LogToRedfish>(type, thresholdValue));
+                actionsIf.emplace_back(std::make_unique<LogToRedfishEventLog>(
+                    type, thresholdValue));
                 break;
             }
             case TriggerAction::UpdateReport:
@@ -120,39 +136,55 @@
 
 namespace discrete
 {
-void LogToJournal::commit(const std::string& sensorName, Milliseconds timestamp,
-                          double value)
+
+void LogToJournal::commit(const std::string& triggerId,
+                          const ThresholdName thresholdNameIn,
+                          const std::string& sensorName,
+                          const Milliseconds timestamp,
+                          const TriggerValue triggerValue)
 {
-    std::string msg = ::discrete::severityToString(severity) +
-                      " discrete threshold condition is met on sensor " +
-                      sensorName + ", recorded value " + std::to_string(value) +
-                      ", timestamp " + timestampToString(timestamp);
+    auto value = std::get<std::string>(triggerValue);
+
+    std::string msg = "Discrete condition '" + thresholdNameIn->get() +
+                      "' of trigger '" + triggerId + "' is met on sensor " +
+                      sensorName + ", recorded value: " + value +
+                      ", severity: " + ::discrete::severityToString(severity) +
+                      ", timestamp: " + timestampToString(timestamp);
 
     phosphor::logging::log<phosphor::logging::level::INFO>(msg.c_str());
 }
 
-const char* LogToRedfish::getMessageId() const
+const char* LogToRedfishEventLog::getRedfishMessageId() const
 {
     switch (severity)
     {
         case ::discrete::Severity::ok:
-            return "OpenBMC.0.1.0.DiscreteThresholdOk";
+            return redfish_message_ids::TriggerDiscreteOK;
         case ::discrete::Severity::warning:
-            return "OpenBMC.0.1.0.DiscreteThresholdWarning";
+            return redfish_message_ids::TriggerDiscreteWarning;
         case ::discrete::Severity::critical:
-            return "OpenBMC.0.1.0.DiscreteThresholdCritical";
+            return redfish_message_ids::TriggerDiscreteCritical;
     }
     throw std::runtime_error("Invalid severity");
 }
 
-void LogToRedfish::commit(const std::string& sensorName, Milliseconds timestamp,
-                          double value)
+void LogToRedfishEventLog::commit(const std::string& triggerId,
+                                  const ThresholdName thresholdNameIn,
+                                  const std::string& sensorName,
+                                  const Milliseconds timestamp,
+                                  const TriggerValue triggerValue)
 {
+    auto value = std::get<std::string>(triggerValue);
+    auto timestampStr = timestampToString(timestamp);
+
     phosphor::logging::log<phosphor::logging::level::INFO>(
-        "Discrete treshold condition is met",
-        phosphor::logging::entry("REDFISH_MESSAGE_ID=%s", getMessageId()),
-        phosphor::logging::entry("REDFISH_MESSAGE_ARGS=%s,%f,%llu",
-                                 sensorName.c_str(), value, timestamp.count()));
+        "Logging discrete trigger action to Redfish Event Log.",
+        phosphor::logging::entry("REDFISH_MESSAGE_ID=%s",
+                                 getRedfishMessageId()),
+        phosphor::logging::entry("REDFISH_MESSAGE_ARGS=%s,%s,%s,%s,%s",
+                                 thresholdNameIn->get().c_str(),
+                                 triggerId.c_str(), sensorName.c_str(),
+                                 value.c_str(), timestampStr.c_str()));
 }
 
 void fillActions(
@@ -166,16 +198,16 @@
     {
         switch (actionType)
         {
-            case TriggerAction::LogToLogService:
+            case TriggerAction::LogToJournal:
             {
                 actionsIf.emplace_back(
                     std::make_unique<LogToJournal>(severity));
                 break;
             }
-            case TriggerAction::RedfishEvent:
+            case TriggerAction::LogToRedfishEventLog:
             {
                 actionsIf.emplace_back(
-                    std::make_unique<LogToRedfish>(severity));
+                    std::make_unique<LogToRedfishEventLog>(severity));
                 break;
             }
             case TriggerAction::UpdateReport:
@@ -190,25 +222,38 @@
 
 namespace onChange
 {
-void LogToJournal::commit(const std::string& sensorName, Milliseconds timestamp,
-                          double value)
+void LogToJournal::commit(const std::string& triggerId,
+                          const ThresholdName thresholdNameIn,
+                          const std::string& sensorName,
+                          const Milliseconds timestamp,
+                          const TriggerValue triggerValue)
 {
-    std::string msg = "Value changed on sensor " + sensorName +
-                      ", recorded value " + std::to_string(value) +
-                      ", timestamp " + timestampToString(timestamp);
+    auto value = triggerValueToString(triggerValue);
+    std::string msg = "Discrete condition 'OnChange' of trigger '" + triggerId +
+                      "' is met on sensor: " + sensorName +
+                      ", recorded value: " + value +
+                      ", timestamp: " + timestampToString(timestamp);
 
     phosphor::logging::log<phosphor::logging::level::INFO>(msg.c_str());
 }
 
-void LogToRedfish::commit(const std::string& sensorName, Milliseconds timestamp,
-                          double value)
+void LogToRedfishEventLog::commit(const std::string& triggerId,
+                                  const ThresholdName thresholdNameIn,
+                                  const std::string& sensorName,
+                                  const Milliseconds timestamp,
+                                  const TriggerValue triggerValue)
 {
-    const char* messageId = "OpenBMC.0.1.0.DiscreteThresholdOnChange";
+    auto value = triggerValueToString(triggerValue);
+    auto timestampStr = timestampToString(timestamp);
+
     phosphor::logging::log<phosphor::logging::level::INFO>(
-        "Uncondtional discrete threshold triggered",
-        phosphor::logging::entry("REDFISH_MESSAGE_ID=%s", messageId),
-        phosphor::logging::entry("REDFISH_MESSAGE_ARGS=%s,%f,%llu",
-                                 sensorName.c_str(), value, timestamp.count()));
+        "Logging onChange discrete trigger action to Redfish Event Log.",
+        phosphor::logging::entry("REDFISH_MESSAGE_ID=%s",
+                                 redfish_message_ids::TriggerDiscreteOK),
+        phosphor::logging::entry("REDFISH_MESSAGE_ARGS=%s,%s,%s,%s,%s",
+                                 "OnChange", triggerId.c_str(),
+                                 sensorName.c_str(), value.c_str(),
+                                 timestampStr.c_str()));
 }
 
 void fillActions(
@@ -221,14 +266,15 @@
     {
         switch (actionType)
         {
-            case TriggerAction::LogToLogService:
+            case TriggerAction::LogToJournal:
             {
                 actionsIf.emplace_back(std::make_unique<LogToJournal>());
                 break;
             }
-            case TriggerAction::RedfishEvent:
+            case TriggerAction::LogToRedfishEventLog:
             {
-                actionsIf.emplace_back(std::make_unique<LogToRedfish>());
+                actionsIf.emplace_back(
+                    std::make_unique<LogToRedfishEventLog>());
                 break;
             }
             case TriggerAction::UpdateReport:
@@ -243,7 +289,11 @@
 } // namespace onChange
 } // namespace discrete
 
-void UpdateReport::commit(const std::string&, Milliseconds, double)
+void UpdateReport::commit(const std::string& triggerId,
+                          const ThresholdName thresholdNameIn,
+                          const std::string& sensorName,
+                          const Milliseconds timestamp,
+                          const TriggerValue triggerValue)
 {
     if (reportIds->empty())
     {
diff --git a/src/trigger_actions.hpp b/src/trigger_actions.hpp
index fdf07fe..a74cc7a 100644
--- a/src/trigger_actions.hpp
+++ b/src/trigger_actions.hpp
@@ -8,6 +8,19 @@
 namespace action
 {
 
+namespace redfish_message_ids
+{
+constexpr const char* TriggerNumericWarning =
+    "OpenBMC.0.1.TriggerNumericWarning";
+constexpr const char* TriggerNumericCritical =
+    "OpenBMC.0.1.TriggerNumericCritical";
+constexpr const char* TriggerDiscreteOK = "OpenBMC.0.1.TriggerDiscreteOK";
+constexpr const char* TriggerDiscreteWarning =
+    "OpenBMC.0.1.TriggerDiscreteWarning";
+constexpr const char* TriggerDiscreteCritical =
+    "OpenBMC.0.1.TriggerDiscreteCritical";
+} // namespace redfish_message_ids
+
 namespace numeric
 {
 class LogToJournal : public interfaces::TriggerAction
@@ -16,28 +29,31 @@
     LogToJournal(::numeric::Type type, double val) : type(type), threshold(val)
     {}
 
-    void commit(const std::string& id, Milliseconds timestamp,
-                double value) override;
+    void commit(const std::string& triggerId, const ThresholdName thresholdName,
+                const std::string& sensorName, const Milliseconds timestamp,
+                const TriggerValue value) override;
 
   private:
-    ::numeric::Type type;
-    double threshold;
+    const ::numeric::Type type;
+    const double threshold;
 };
 
-class LogToRedfish : public interfaces::TriggerAction
+class LogToRedfishEventLog : public interfaces::TriggerAction
 {
   public:
-    LogToRedfish(::numeric::Type type, double val) : type(type), threshold(val)
+    LogToRedfishEventLog(::numeric::Type type, double val) :
+        type(type), threshold(val)
     {}
 
-    void commit(const std::string& id, Milliseconds timestamp,
-                double value) override;
+    void commit(const std::string& triggerId, const ThresholdName thresholdName,
+                const std::string& sensorName, const Milliseconds timestamp,
+                const TriggerValue value) override;
 
   private:
-    ::numeric::Type type;
-    double threshold;
+    const ::numeric::Type type;
+    const double threshold;
 
-    const char* getMessageId() const;
+    const char* getRedfishMessageId() const;
 };
 
 void fillActions(
@@ -55,26 +71,29 @@
     explicit LogToJournal(::discrete::Severity severity) : severity(severity)
     {}
 
-    void commit(const std::string& id, Milliseconds timestamp,
-                double value) override;
+    void commit(const std::string& triggerId, const ThresholdName thresholdName,
+                const std::string& sensorName, const Milliseconds timestamp,
+                const TriggerValue value) override;
 
   private:
-    ::discrete::Severity severity;
+    const ::discrete::Severity severity;
 };
 
-class LogToRedfish : public interfaces::TriggerAction
+class LogToRedfishEventLog : public interfaces::TriggerAction
 {
   public:
-    explicit LogToRedfish(::discrete::Severity severity) : severity(severity)
+    explicit LogToRedfishEventLog(::discrete::Severity severity) :
+        severity(severity)
     {}
 
-    void commit(const std::string& id, Milliseconds timestamp,
-                double value) override;
+    void commit(const std::string& triggerId, const ThresholdName thresholdName,
+                const std::string& sensorName, const Milliseconds timestamp,
+                const TriggerValue value) override;
 
   private:
-    ::discrete::Severity severity;
+    const ::discrete::Severity severity;
 
-    const char* getMessageId() const;
+    const char* getRedfishMessageId() const;
 };
 
 void fillActions(
@@ -91,18 +110,20 @@
     LogToJournal()
     {}
 
-    void commit(const std::string& id, Milliseconds timestamp,
-                double value) override;
+    void commit(const std::string& triggerId, const ThresholdName thresholdName,
+                const std::string& sensorName, const Milliseconds timestamp,
+                const TriggerValue value) override;
 };
 
-class LogToRedfish : public interfaces::TriggerAction
+class LogToRedfishEventLog : public interfaces::TriggerAction
 {
   public:
-    LogToRedfish()
+    LogToRedfishEventLog()
     {}
 
-    void commit(const std::string& id, Milliseconds timestamp,
-                double value) override;
+    void commit(const std::string& triggerId, const ThresholdName thresholdName,
+                const std::string& sensorName, const Milliseconds timestamp,
+                const TriggerValue value) override;
 };
 
 void fillActions(
@@ -122,8 +143,9 @@
         reportIds(std::move(ids))
     {}
 
-    void commit(const std::string& id, Milliseconds timestamp,
-                double value) override;
+    void commit(const std::string& triggerId, const ThresholdName thresholdName,
+                const std::string& sensorName, const Milliseconds timestamp,
+                const TriggerValue value) override;
 
   private:
     boost::asio::io_context& ioc;
diff --git a/src/trigger_factory.cpp b/src/trigger_factory.cpp
index 6c9ceb9..615d42d 100644
--- a/src/trigger_factory.cpp
+++ b/src/trigger_factory.cpp
@@ -6,6 +6,7 @@
 #include "sensor.hpp"
 #include "trigger.hpp"
 #include "trigger_actions.hpp"
+#include "utils/clock.hpp"
 #include "utils/dbus_mapper.hpp"
 #include "utils/transform.hpp"
 
@@ -21,6 +22,7 @@
 
 void TriggerFactory::updateDiscreteThresholds(
     std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+    const std::string& triggerId,
     const std::vector<TriggerAction>& triggerActions,
     const std::shared_ptr<std::vector<std::string>>& reportIds,
     const Sensors& sensors,
@@ -57,16 +59,16 @@
                 continue;
             }
 
-            makeDiscreteThreshold(newThresholds, triggerActions, reportIds,
-                                  sensors, labeledThresholdParam);
+            makeDiscreteThreshold(newThresholds, triggerId, triggerActions,
+                                  reportIds, sensors, labeledThresholdParam);
         }
     }
     else
     {
         for (const auto& labeledThresholdParam : newParams)
         {
-            makeDiscreteThreshold(newThresholds, triggerActions, reportIds,
-                                  sensors, labeledThresholdParam);
+            makeDiscreteThreshold(newThresholds, triggerId, triggerActions,
+                                  reportIds, sensors, labeledThresholdParam);
         }
     }
     if (newParams.empty())
@@ -77,8 +79,8 @@
         }
         else
         {
-            makeOnChangeThreshold(newThresholds, triggerActions, reportIds,
-                                  sensors);
+            makeOnChangeThreshold(newThresholds, triggerId, triggerActions,
+                                  reportIds, sensors);
         }
     }
     currentThresholds = std::move(newThresholds);
@@ -86,6 +88,7 @@
 
 void TriggerFactory::updateNumericThresholds(
     std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+    const std::string& triggerId,
     const std::vector<TriggerAction>& triggerActions,
     const std::shared_ptr<std::vector<std::string>>& reportIds,
     const Sensors& sensors,
@@ -112,14 +115,15 @@
             continue;
         }
 
-        makeNumericThreshold(newThresholds, triggerActions, reportIds, sensors,
-                             labeledThresholdParam);
+        makeNumericThreshold(newThresholds, triggerId, triggerActions,
+                             reportIds, sensors, labeledThresholdParam);
     }
     currentThresholds = std::move(newThresholds);
 }
 
 void TriggerFactory::updateThresholds(
     std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+    const std::string& triggerId,
     const std::vector<TriggerAction>& triggerActions,
     const std::shared_ptr<std::vector<std::string>>& reportIds,
     const Sensors& sensors,
@@ -130,21 +134,24 @@
         const auto& labeledDiscreteThresholdParams =
             std::get<std::vector<discrete::LabeledThresholdParam>>(newParams);
 
-        updateDiscreteThresholds(currentThresholds, triggerActions, reportIds,
-                                 sensors, labeledDiscreteThresholdParams);
+        updateDiscreteThresholds(currentThresholds, triggerId, triggerActions,
+                                 reportIds, sensors,
+                                 labeledDiscreteThresholdParams);
     }
     else
     {
         const auto& labeledNumericThresholdParams =
             std::get<std::vector<numeric::LabeledThresholdParam>>(newParams);
 
-        updateNumericThresholds(currentThresholds, triggerActions, reportIds,
-                                sensors, labeledNumericThresholdParams);
+        updateNumericThresholds(currentThresholds, triggerId, triggerActions,
+                                reportIds, sensors,
+                                labeledNumericThresholdParams);
     }
 }
 
 void TriggerFactory::makeDiscreteThreshold(
     std::vector<std::shared_ptr<interfaces::Threshold>>& thresholds,
+    const std::string& triggerId,
     const std::vector<TriggerAction>& triggerActions,
     const std::shared_ptr<std::vector<std::string>>& reportIds,
     const Sensors& sensors,
@@ -152,21 +159,24 @@
 {
     std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
 
-    std::string thresholdName = thresholdParam.at_label<ts::UserId>();
+    const std::string& thresholdName = thresholdParam.at_label<ts::UserId>();
     discrete::Severity severity = thresholdParam.at_label<ts::Severity>();
     auto dwellTime = Milliseconds(thresholdParam.at_label<ts::DwellTime>());
-    std::string thresholdValue = thresholdParam.at_label<ts::ThresholdValue>();
+    const std::string& thresholdValue =
+        thresholdParam.at_label<ts::ThresholdValue>();
 
     action::discrete::fillActions(actions, triggerActions, severity,
                                   bus->get_io_context(), reportIds);
 
     thresholds.emplace_back(std::make_shared<DiscreteThreshold>(
-        bus->get_io_context(), sensors, std::move(actions),
-        Milliseconds(dwellTime), thresholdValue, thresholdName, severity));
+        bus->get_io_context(), triggerId, sensors, std::move(actions),
+        Milliseconds(dwellTime), thresholdValue, thresholdName, severity,
+        std::make_unique<Clock>()));
 }
 
 void TriggerFactory::makeNumericThreshold(
     std::vector<std::shared_ptr<interfaces::Threshold>>& thresholds,
+    const std::string& triggerId,
     const std::vector<TriggerAction>& triggerActions,
     const std::shared_ptr<std::vector<std::string>>& reportIds,
     const Sensors& sensors,
@@ -183,12 +193,13 @@
                                  bus->get_io_context(), reportIds);
 
     thresholds.emplace_back(std::make_shared<NumericThreshold>(
-        bus->get_io_context(), sensors, std::move(actions), dwellTime,
-        direction, thresholdValue, type));
+        bus->get_io_context(), triggerId, sensors, std::move(actions),
+        dwellTime, direction, thresholdValue, type, std::make_unique<Clock>()));
 }
 
 void TriggerFactory::makeOnChangeThreshold(
     std::vector<std::shared_ptr<interfaces::Threshold>>& thresholds,
+    const std::string& triggerId,
     const std::vector<TriggerAction>& triggerActions,
     const std::shared_ptr<std::vector<std::string>>& reportIds,
     const Sensors& sensors) const
@@ -198,12 +209,12 @@
     action::discrete::onChange::fillActions(actions, triggerActions,
                                             bus->get_io_context(), reportIds);
 
-    thresholds.emplace_back(
-        std::make_shared<OnChangeThreshold>(sensors, std::move(actions)));
+    thresholds.emplace_back(std::make_shared<OnChangeThreshold>(
+        triggerId, sensors, std::move(actions), std::make_unique<Clock>()));
 }
 
 std::unique_ptr<interfaces::Trigger> TriggerFactory::make(
-    const std::string& id, const std::string& name,
+    const std::string& idIn, const std::string& name,
     const std::vector<std::string>& triggerActionsIn,
     const std::vector<std::string>& reportIdsIn,
     interfaces::TriggerManager& triggerManager,
@@ -217,15 +228,17 @@
             return toTriggerAction(triggerActionStr);
         });
     std::vector<std::shared_ptr<interfaces::Threshold>> thresholds;
+    auto id = std::make_unique<const std::string>(idIn);
 
     auto reportIds = std::make_shared<std::vector<std::string>>(reportIdsIn);
 
-    updateThresholds(thresholds, triggerActions, reportIds, sensors,
+    updateThresholds(thresholds, *id, triggerActions, reportIds, sensors,
                      labeledThresholdParams);
 
     return std::make_unique<Trigger>(
-        bus->get_io_context(), objServer, id, name, triggerActions, reportIds,
-        std::move(thresholds), triggerManager, triggerStorage, *this, sensors);
+        bus->get_io_context(), objServer, std::move(id), name, triggerActions,
+        reportIds, std::move(thresholds), triggerManager, triggerStorage, *this,
+        sensors);
 }
 
 Sensors TriggerFactory::getSensors(
diff --git a/src/trigger_factory.hpp b/src/trigger_factory.hpp
index 40dfcfd..a2ad568 100644
--- a/src/trigger_factory.hpp
+++ b/src/trigger_factory.hpp
@@ -34,6 +34,7 @@
 
     void updateThresholds(
         std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+        const std::string& triggerId,
         const std::vector<TriggerAction>& triggerActions,
         const std::shared_ptr<std::vector<std::string>>& reportIds,
         const Sensors& sensors,
@@ -57,6 +58,7 @@
 
     void updateDiscreteThresholds(
         std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+        const std::string& triggerId,
         const std::vector<TriggerAction>& triggerActions,
         const std::shared_ptr<std::vector<std::string>>& reportIds,
         const Sensors& sensors,
@@ -64,6 +66,7 @@
 
     void updateNumericThresholds(
         std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+        const std::string& triggerId,
         const std::vector<TriggerAction>& triggerActions,
         const std::shared_ptr<std::vector<std::string>>& reportIds,
         const Sensors& sensors,
@@ -71,6 +74,7 @@
 
     void makeDiscreteThreshold(
         std::vector<std::shared_ptr<interfaces::Threshold>>& thresholds,
+        const std::string& triggerId,
         const std::vector<TriggerAction>& triggerActions,
         const std::shared_ptr<std::vector<std::string>>& reportIds,
         const Sensors& sensors,
@@ -78,6 +82,7 @@
 
     void makeNumericThreshold(
         std::vector<std::shared_ptr<interfaces::Threshold>>& thresholds,
+        const std::string& triggerId,
         const std::vector<TriggerAction>& triggerActions,
         const std::shared_ptr<std::vector<std::string>>& reportIds,
         const Sensors& sensors,
@@ -85,6 +90,7 @@
 
     void makeOnChangeThreshold(
         std::vector<std::shared_ptr<interfaces::Threshold>>& thresholds,
+        const std::string& triggerId,
         const std::vector<TriggerAction>& triggerActions,
         const std::shared_ptr<std::vector<std::string>>& reportIds,
         const Sensors& sensors) const;
diff --git a/src/types/trigger_types.hpp b/src/types/trigger_types.hpp
index 778a9a1..4d0b3bd 100644
--- a/src/types/trigger_types.hpp
+++ b/src/types/trigger_types.hpp
@@ -13,8 +13,8 @@
 
 enum class TriggerAction
 {
-    LogToLogService = 0,
-    RedfishEvent,
+    LogToJournal = 0,
+    LogToRedfishEventLog,
     UpdateReport,
 };
 
@@ -22,8 +22,9 @@
 {
 constexpr std::array<std::pair<std::string_view, TriggerAction>, 3>
     convDataTriggerAction = {
-        std::make_pair("LogToLogService", TriggerAction::LogToLogService),
-        std::make_pair("RedfishEvent", TriggerAction::RedfishEvent),
+        std::make_pair("LogToJournal", TriggerAction::LogToJournal),
+        std::make_pair("LogToRedfishEventLog",
+                       TriggerAction::LogToRedfishEventLog),
         std::make_pair("UpdateReport", TriggerAction::UpdateReport)};
 }
 
@@ -160,3 +161,19 @@
     return std::holds_alternative<std::vector<discrete::LabeledThresholdParam>>(
         params);
 }
+
+using TriggerId = std::unique_ptr<const std::string>;
+using TriggerValue = std::variant<double, std::string>;
+using ThresholdName = std::optional<std::reference_wrapper<const std::string>>;
+
+inline std::string triggerValueToString(TriggerValue val)
+{
+    if (auto* doubleVal = std::get_if<double>(&val); doubleVal != nullptr)
+    {
+        return std::to_string(*doubleVal);
+    }
+    else
+    {
+        return std::get<std::string>(val);
+    }
+}