diff --git a/Redfish.md b/Redfish.md
index 811dc87..cdec1f9 100644
--- a/Redfish.md
+++ b/Redfish.md
@@ -606,6 +606,14 @@
 #### ManagerDiagnosticData
 
 - ServiceRootUptimeSeconds
+- FreeStorageSpaceKiB
+- MemoryStatistics/AvailableBytes
+- MemoryStatistics/BuffersAndCacheBytes
+- MemoryStatistics/FreeBytes
+- MemoryStatistics/SharedBytes
+- MemoryStatistics/TotalBytes
+- ProcessorStatistics/KernelPercent
+- ProcessorStatistics/UserPercent
 
 ### /redfish/v1/Managers/bmc/NetworkProtocol/
 
diff --git a/meson.build b/meson.build
index 6184f62..f4976c1 100644
--- a/meson.build
+++ b/meson.build
@@ -461,6 +461,7 @@
   'test/redfish-core/lib/service_root_test.cpp',
   'test/redfish-core/lib/thermal_subsystem_test.cpp',
   'test/redfish-core/lib/power_subsystem_test.cpp',
+  'test/redfish-core/lib/manager_diagnostic_data_test.cpp',
 )
 
 
diff --git a/redfish-core/lib/manager_diagnostic_data.hpp b/redfish-core/lib/manager_diagnostic_data.hpp
index 4dedc3f..1ff116f 100644
--- a/redfish-core/lib/manager_diagnostic_data.hpp
+++ b/redfish-core/lib/manager_diagnostic_data.hpp
@@ -8,14 +8,174 @@
 #include "registries/privilege_registry.hpp"
 #include "routing.hpp"
 
+#include <boost/system/error_code.hpp>
+#include <boost/system/linux_error.hpp>
 #include <nlohmann/json.hpp>
 #include <sdbusplus/asio/property.hpp>
 
+#include <functional>
+#include <limits>
+#include <memory>
 #include <string>
 
 namespace redfish
 {
 
+static constexpr auto healthMonitorServiceName =
+    "xyz.openbmc_project.HealthMon";
+static constexpr auto valueInterface = "xyz.openbmc_project.Metric.Value";
+static constexpr auto valueProperty = "Value";
+
+inline bool checkErrors(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+    const boost::system::error_code& ec,
+    const std::source_location src = std::source_location::current())
+{
+    if (ec.value() == boost::asio::error::basic_errors::host_unreachable)
+    {
+        BMCWEB_LOG_WARNING("Failed to find server, Dbus error {}", ec);
+        return true;
+    }
+    if (ec.value() == boost::system::linux_error::bad_request_descriptor)
+    {
+        BMCWEB_LOG_WARNING("Invalid Path, Dbus error {}", ec);
+        return true;
+    }
+    if (ec)
+    {
+        BMCWEB_LOG_ERROR("{} failed, error {}", src.function_name(), ec);
+        messages::internalError(asyncResp->res);
+        return true;
+    }
+    return false;
+}
+
+inline void
+    setBytesProperty(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                     const nlohmann::json::json_pointer& jPtr,
+                     const boost::system::error_code& ec, double bytes)
+{
+    if (checkErrors(asyncResp, ec))
+    {
+        return;
+    }
+    if (!std::isfinite(bytes))
+    {
+        BMCWEB_LOG_WARNING("Property read for {} was not finite",
+                           jPtr.to_string());
+        asyncResp->res.jsonValue[jPtr] = nullptr;
+        return;
+    }
+    // If the param is in Kib, make it Kib.  Redfish uses this as a naming
+    // DBus represents as bytes
+    if (std::string_view(jPtr.back()).ends_with("KiB"))
+    {
+        bytes /= 1024.0;
+    }
+
+    asyncResp->res.jsonValue[jPtr] = static_cast<int64_t>(bytes);
+}
+
+inline void managerGetStorageStatistics(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+{
+    constexpr auto freeStorageObjPath =
+        "/xyz/openbmc_project/metric/bmc/storage/rw";
+
+    sdbusplus::asio::getProperty<double>(
+        *crow::connections::systemBus, healthMonitorServiceName,
+        freeStorageObjPath, valueInterface, valueProperty,
+        std::bind_front(setBytesProperty, asyncResp,
+                        nlohmann::json::json_pointer("/FreeStorageSpaceKiB")));
+}
+
+inline void
+    setPercentProperty(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                       const nlohmann::json::json_pointer& jPtr,
+                       const boost::system::error_code& ec, double userCPU)
+{
+    if (checkErrors(asyncResp, ec))
+    {
+        return;
+    }
+    if (!std::isfinite(userCPU))
+    {
+        asyncResp->res.jsonValue[jPtr] = nullptr;
+        return;
+    }
+
+    static constexpr double roundFactor = 10000; // 4 decimal places
+    asyncResp->res.jsonValue[jPtr] = std::round(userCPU * roundFactor) /
+                                     roundFactor;
+}
+
+inline void managerGetProcessorStatistics(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+{
+    constexpr auto kernelCPUObjPath =
+        "/xyz/openbmc_project/metric/bmc/cpu/kernel";
+    constexpr auto userCPUObjPath = "/xyz/openbmc_project/metric/bmc/cpu/user";
+
+    using json_pointer = nlohmann::json::json_pointer;
+    sdbusplus::asio::getProperty<double>(
+        *crow::connections::systemBus, healthMonitorServiceName,
+        kernelCPUObjPath, valueInterface, valueProperty,
+        std::bind_front(setPercentProperty, asyncResp,
+                        json_pointer("/ProcessorStatistics/KernelPercent")));
+
+    sdbusplus::asio::getProperty<double>(
+        *crow::connections::systemBus, healthMonitorServiceName, userCPUObjPath,
+        valueInterface, valueProperty,
+        std::bind_front(setPercentProperty, asyncResp,
+                        json_pointer("/ProcessorStatistics/UserPercent")));
+}
+
+inline void managerGetMemoryStatistics(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+{
+    using json_pointer = nlohmann::json::json_pointer;
+    constexpr auto availableMemoryObjPath =
+        "/xyz/openbmc_project/metric/bmc/memory/available";
+    sdbusplus::asio::getProperty<double>(
+        *crow::connections::systemBus, healthMonitorServiceName,
+        availableMemoryObjPath, valueInterface, valueProperty,
+        std::bind_front(setBytesProperty, asyncResp,
+                        json_pointer("/MemoryStatistics/AvailableBytes")));
+
+    constexpr auto bufferedAndCachedMemoryObjPath =
+        "/xyz/openbmc_project/metric/bmc/memory/buffered_and_cached";
+    sdbusplus::asio::getProperty<double>(
+        *crow::connections::systemBus, healthMonitorServiceName,
+        bufferedAndCachedMemoryObjPath, valueInterface, valueProperty,
+        std::bind_front(
+            setBytesProperty, asyncResp,
+            json_pointer("/MemoryStatistics/BuffersAndCacheBytes")));
+
+    constexpr auto freeMemoryObjPath =
+        "/xyz/openbmc_project/metric/bmc/memory/free";
+    sdbusplus::asio::getProperty<double>(
+        *crow::connections::systemBus, healthMonitorServiceName,
+        freeMemoryObjPath, valueInterface, valueProperty,
+        std::bind_front(setBytesProperty, asyncResp,
+                        json_pointer("/MemoryStatistics/FreeBytes")));
+
+    constexpr auto sharedMemoryObjPath =
+        "/xyz/openbmc_project/metric/bmc/memory/shared";
+    sdbusplus::asio::getProperty<double>(
+        *crow::connections::systemBus, healthMonitorServiceName,
+        sharedMemoryObjPath, valueInterface, valueProperty,
+        std::bind_front(setBytesProperty, asyncResp,
+                        json_pointer("/MemoryStatistics/SharedBytes")));
+
+    constexpr auto totalMemoryObjPath =
+        "/xyz/openbmc_project/metric/bmc/memory/total";
+    sdbusplus::asio::getProperty<double>(
+        *crow::connections::systemBus, healthMonitorServiceName,
+        totalMemoryObjPath, valueInterface, valueProperty,
+        std::bind_front(setBytesProperty, asyncResp,
+                        json_pointer("/MemoryStatistics/TotalBytes")));
+}
+
 inline void afterGetManagerStartTime(
     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
     const boost::system::error_code& ec, uint64_t bmcwebResetTime)
@@ -82,6 +242,9 @@
     asyncResp->res.jsonValue["Name"] = "Manager Diagnostic Data";
 
     managerGetServiceRootUptime(asyncResp);
+    managerGetProcessorStatistics(asyncResp);
+    managerGetMemoryStatistics(asyncResp);
+    managerGetStorageStatistics(asyncResp);
 }
 
 inline void requestRoutesManagerDiagnosticData(App& app)
diff --git a/test/redfish-core/lib/manager_diagnostic_data_test.cpp b/test/redfish-core/lib/manager_diagnostic_data_test.cpp
new file mode 100644
index 0000000..b59842a
--- /dev/null
+++ b/test/redfish-core/lib/manager_diagnostic_data_test.cpp
@@ -0,0 +1,75 @@
+#include "async_resp.hpp"
+#include "manager_diagnostic_data.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <memory>
+
+#include <gtest/gtest.h>
+
+namespace redfish
+{
+namespace
+{
+
+using json_pointer = nlohmann::json::json_pointer;
+
+void testDataGetNoError(boost::system::error_code ec)
+{
+    auto asyncResp = std::make_shared<bmcweb::AsyncResp>();
+
+    setBytesProperty(asyncResp,
+                     json_pointer("/MemoryStatistics/FreeStorageSpace"), ec, 0);
+    EXPECT_TRUE(asyncResp->res.jsonValue.is_null());
+    EXPECT_EQ(asyncResp->res.result(), boost::beast::http::status::ok);
+}
+
+TEST(ManagerDiagnosticDataTest, ManagerDataGetServerUnreachable)
+{
+    testDataGetNoError(boost::asio::error::basic_errors::host_unreachable);
+}
+
+TEST(ManagerDiagnosticDataTest, ManagerDataGetPathInvalid)
+{
+    testDataGetNoError(boost::system::linux_error::bad_request_descriptor);
+}
+
+void verifyError(crow::Response& res)
+{
+    EXPECT_EQ(res.result(), boost::beast::http::status::internal_server_error);
+    res.clear();
+}
+
+TEST(ManagerDiagnosticDataTest, ManagerDataGetFailure)
+{
+    auto asyncResp = std::make_shared<bmcweb::AsyncResp>();
+    boost::system::error_code ec = boost::asio::error::operation_aborted;
+
+    setBytesProperty(asyncResp,
+                     json_pointer("/MemoryStatistics/FreeStorageSpace"), ec, 0);
+    verifyError(asyncResp->res);
+}
+
+TEST(ManagerDiagnosticDataTest, ManagerDataGetNullPtr)
+{
+    auto asyncResp = std::make_shared<bmcweb::AsyncResp>();
+
+    setPercentProperty(
+        asyncResp,
+        nlohmann::json::json_pointer("/MemoryStatistics/FreeStorageSpace"), {},
+        std::numeric_limits<double>::quiet_NaN());
+    EXPECT_EQ(asyncResp->res.jsonValue["FreeStorageSpaceKiB"], nullptr);
+}
+
+TEST(ManagerDiagnosticDataTest, ManagerDataGetSuccess)
+{
+    auto asyncResp = std::make_shared<bmcweb::AsyncResp>();
+
+    setBytesProperty(asyncResp, json_pointer("/FreeStorageSpaceKiB"), {},
+                     204800.0);
+    EXPECT_EQ(asyncResp->res.jsonValue["FreeStorageSpaceKiB"].get<int64_t>(),
+              200);
+}
+
+} // namespace
+} // namespace redfish