diff --git a/sensor-monitor/threshold_alarm_logger.cpp b/sensor-monitor/threshold_alarm_logger.cpp
index 08a3a2c..bab6002 100644
--- a/sensor-monitor/threshold_alarm_logger.cpp
+++ b/sensor-monitor/threshold_alarm_logger.cpp
@@ -35,6 +35,12 @@
     "xyz.openbmc_project.Sensor.Threshold.Critical";
 const std::string perfLossInterface =
     "xyz.openbmc_project.Sensor.Threshold.PerformanceLoss";
+constexpr auto loggingService = "xyz.openbmc_project.Logging";
+constexpr auto loggingPath = "/xyz/openbmc_project/logging";
+constexpr auto loggingCreateIface = "xyz.openbmc_project.Logging.Create";
+constexpr auto errorNameBase = "xyz.openbmc_project.Sensor.Threshold.Error.";
+constexpr auto valueInterface = "xyz.openbmc_project.Sensor.Value";
+constexpr auto assocInterface = "xyz.openbmc_project.Association";
 
 using ErrorData = std::tuple<ErrorName, Entry::Level>;
 
@@ -198,7 +204,128 @@
                                           const std::string& alarmProperty,
                                           bool alarmValue)
 {
-    // TODO
+    std::map<std::string, std::string> ad;
+
+    auto type = getSensorType(sensorPath);
+    if (skipSensorType(type))
+    {
+        return;
+    }
+
+    auto it = thresholdData.find(interface);
+    if (it == thresholdData.end())
+    {
+        return;
+    }
+
+    auto properties = it->second.find(alarmProperty);
+    if (properties == it->second.end())
+    {
+        log<level::INFO>(
+            fmt::format("Could not find {} in threshold alarms map",
+                        alarmProperty)
+                .c_str());
+        return;
+    }
+
+    ad.emplace("SENSOR_NAME", sensorPath);
+
+    try
+    {
+        auto sensorValue = SDBusPlus::getProperty<double>(
+            bus, sensorPath, valueInterface, "Value");
+
+        ad.emplace("SENSOR_VALUE", std::to_string(sensorValue));
+
+        log<level::INFO>(
+            fmt::format("Threshold Event {} {} = {} (sensor value {})",
+                        sensorPath, alarmProperty, alarmValue, sensorValue)
+                .c_str());
+    }
+    catch (const DBusServiceError& e)
+    {
+        // If the sensor was just added, the Value interface for it may
+        // not be in the mapper yet.  This could only happen if the sensor
+        // application was started up after this one and the value exceeded the
+        // threshold immediately.
+        log<level::INFO>(fmt::format("Threshold Event {} {} = {}", sensorPath,
+                                     alarmProperty, alarmValue)
+                             .c_str());
+    }
+
+    auto callout = getCallout(sensorPath);
+    if (!callout.empty())
+    {
+        ad.emplace("CALLOUT_INVENTORY_PATH", callout);
+    }
+
+    auto errorData = properties->second.find(alarmValue);
+
+    // Add the base error name and the sensor type (like Temperature) to the
+    // error name that's in the thresholdData name to get something like
+    // xyz.openbmc_project.Sensor.Threshold.Error.TemperatureWarningHigh
+    const auto& [name, severity] = errorData->second;
+    type.front() = toupper(type.front());
+    std::string errorName = errorNameBase + type + name;
+
+    SDBusPlus::callMethod(loggingService, loggingPath, loggingCreateIface,
+                          "Create", errorName, convertForMessage(severity), ad);
+}
+
+std::string ThresholdAlarmLogger::getSensorType(std::string sensorPath)
+{
+    auto pos = sensorPath.find_last_of('/');
+    if ((sensorPath.back() == '/') || (pos == std::string::npos))
+    {
+        log<level::ERR>(
+            fmt::format("Cannot get sensor type from sensor path {}",
+                        sensorPath)
+                .c_str());
+        throw std::runtime_error("Invalid sensor path");
+    }
+
+    sensorPath = sensorPath.substr(0, pos);
+    return sensorPath.substr(sensorPath.find_last_of('/') + 1);
+}
+
+bool ThresholdAlarmLogger::skipSensorType(const std::string& type)
+{
+    return (type == "utilization");
+}
+
+std::string ThresholdAlarmLogger::getCallout(const std::string& sensorPath)
+{
+    const std::array<std::string, 2> assocTypes{"inventory", "chassis"};
+
+    // Different implementations handle the association to the FRU
+    // differently:
+    //  * phosphor-inventory-manager uses the 'inventory' association
+    //    to point to the FRU.
+    //  * dbus-sensors/entity-manager uses the 'chassis' association'.
+    //  * For virtual sensors, no association.
+
+    for (const auto& assocType : assocTypes)
+    {
+        auto assocPath = sensorPath + "/" + assocType;
+
+        try
+        {
+            auto endpoints = SDBusPlus::getProperty<std::vector<std::string>>(
+                bus, assocPath, assocInterface, "endpoints");
+
+            if (!endpoints.empty())
+            {
+                return endpoints[0];
+            }
+        }
+        catch (const DBusServiceError& e)
+        {
+            // The association doesn't exist
+            continue;
+        }
+    }
+
+    return std::string{};
 }
 
 } // namespace sensor::monitor
diff --git a/sensor-monitor/threshold_alarm_logger.hpp b/sensor-monitor/threshold_alarm_logger.hpp
index c95f396..07dce13 100644
--- a/sensor-monitor/threshold_alarm_logger.hpp
+++ b/sensor-monitor/threshold_alarm_logger.hpp
@@ -99,6 +99,42 @@
                         const std::string& alarmProperty, bool alarmValue);
 
     /**
+     * @brief Returns the type of the sensor using the path segment
+     *        that precedes the sensor name.
+     *
+     * /xyz/openbmc_project/sensors/voltage/vout -> type == voltage
+     *
+     * @param[in] sensorPath - The sensor object path name
+     *
+     * @return std::string The type segment
+     */
+    std::string getSensorType(std::string sensorPath);
+
+    /**
+     * @brief Allows for skipping event logs based on the sensor type.
+     *
+     * Specifically for the 'utilization' type because its provider
+     * doesn't support configurable thresholds yet.
+     *
+     * @param[in] type - The sensor type, like 'temperature'.
+     * @return bool - If it can be skipped or not.
+     */
+    bool skipSensorType(const std::string& type);
+
+    /**
+     * @brief Returns the inventory path to use for a FRU callout
+     *        for the alarm exceeded errors.
+     *
+     * It finds the path by looking for 'inventory' or 'chassis'
+     * association objects on the sensor that point to a FRU.
+     *
+     * @param[in] std::string - The sensor object path
+     * @return std::string - The inventory path for the FRU callout.
+     *                       May be empty if none found.
+     */
+    std::string getCallout(const std::string& sensorPath);
+
+    /**
      * @brief The sdbusplus bus object
      */
     sdbusplus::bus::bus& bus;