sensor_utils: Add PeakReading property

Add support for PeakReading and PeakReadingTime for sensors. This
enhancement allows sensor readings to include max observed value
information in the Redfish API, along with timestamp. It uses PDI
xyz.openbmc_project.Telemetry.Report. Property PeakReading is added if
OperationType in PDI property ReadingParameters is set to Maximum.

Current Limitation -
The ResetMetrics action is currently not supported for sensor URIs. As a
result, the ability to clear PeakReading values for GPU Power Sensors
has not been implemented.

Future Consideration -
If ResetMetrics action support is added in the future, the corresponding
functionality will also need to be implemented in the dbus-sensor
application to ensure full compatibility.

Schema:
https://redfish.dmtf.org/schemas/v1/Sensor.v1_2_0.yaml (PeakReading)

Backend implementation for reference:
https://gerrit.openbmc.org/c/openbmc/dbus-sensors/+/82479

Tested: Build an image for nvl32-obmc machine with the following patches
cherry picked.

https://gerrit.openbmc.org/c/openbmc/openbmc/+/85490
https://gerrit.openbmc.org/c/openbmc/bmcweb/+/82449.

The patch cherry-picks the following patches that are currently under
review.

```
1. device tree
https://lore.kernel.org/all/[email protected]/
2. mctpd patches
CodeConstruct/mctp#85
3. u-boot changes
https://lore.kernel.org/openbmc/[email protected]/T/#t
4. kernel changes as specified in the openbmc patch (for espi)
5. entity-manager changes
https://gerrit.openbmc.org/c/openbmc/entity-manager/+/85455
6. platform-init changes
https://gerrit.openbmc.org/c/openbmc/platform-init/+/85456
7. spi changes
https://lore.kernel.org/all/[email protected]/
```

```
> curl -s -k -u 'root:0penBmc' https://10.137.203.137/redfish/v1/Chassis/NVIDIA_GB200_1/Sensors/power_NVIDIA_GB200_GPU_0_Power_0
{
  "@odata.id": "/redfish/v1/Chassis/NVIDIA_GB200_1/Sensors/power_NVIDIA_GB200_GPU_0_Power_0",
  "@odata.type": "#Sensor.v1_2_0.Sensor",
  "Id": "power_NVIDIA_GB200_GPU_0_Power_0",
  "Name": "NVIDIA GB200 GPU 0 Power 0",
  "PeakReading": 52.671,
  "PeakReadingTime": 0,
  "Reading": 27.214,
  "ReadingRangeMax": 5000.0,
  "ReadingRangeMin": 0.0,
  "ReadingType": "Power",
  "ReadingUnits": "W",
  "Status": {
    "Health": "OK",
    "State": "Enabled"
  }
}%
````

Change-Id: I8c1ab6ce85f31419db4a1d931bf99722d24afbd7
Signed-off-by: Harshit Aghera <[email protected]>

Author: harshit-aghera

docs/Redfish.md

@@ -291,6 +291,8 @@ Fields common to all schemas
 #### Sensor
 
 - Implementation
+- PeakReading
+- PeakReadingTime
 - Reading
 - ReadingBasis
 - ReadingRangeMax

include/dbus_utility.hpp

@@ -49,6 +49,7 @@ using DbusVariantType = std::variant<
     std::vector<uint16_t>,
     sdbusplus::message::object_path,
     std::tuple<uint64_t, std::vector<std::tuple<std::string, double, uint64_t>>>,
+    std::tuple<uint64_t, std::vector<std::tuple<std::string, std::string, double, uint64_t>>>,
     std::vector<sdbusplus::message::object_path>,
     std::vector<std::tuple<std::string, std::string>>,
     std::vector<std::tuple<uint32_t, std::vector<uint32_t>>>,

redfish-core/include/utils/sensor_utils.hpp

@@ -288,6 +288,47 @@ inline sensor::ReadingType toReadingType(std::string_view sensorType)
 
 } // namespace sensors
 
+// represents metric Id, metadata, reading value and timestamp of single
+// reading update in milliseconds
+using Reading = std::tuple<std::string, std::string, double, uint64_t>;
+// represents multiple independent readings
+using Readings = std::vector<Reading>;
+// represents a timestamp and multiple independent readings
+using Statistics = std::tuple<uint64_t, Readings>;
+// represents sensor's path, its metadata
+using SensorPaths =
+    std::vector<std::tuple<sdbusplus::message::object_path, std::string>>;
+// represents reading parameters for statistics readings
+using ReadingParameters =
+    std::vector<std::tuple<SensorPaths, std::string, std::string, uint64_t>>;
+
+inline void updateSensorStatistics(
+    nlohmann::json& sensorJson, const std::optional<Statistics>& statistics,
+    const std::optional<ReadingParameters>& readingParameters)
+{
+    if (statistics.has_value() && readingParameters.has_value())
+    {
+        Readings metrics = std::get<1>(*statistics);
+        for (const auto& [sensorPaths, operationType, metricId, duration] :
+             *readingParameters)
+        {
+            if (operationType ==
+                "xyz.openbmc_project.Telemetry.Report.OperationType.Maximum")
+            {
+                if (metrics.size() == 1)
+                {
+                    const auto& [id, metadata, value, timestamp] = metrics[0];
+                    sensorJson["PeakReading"] = value;
+                    if (timestamp != 0)
+                    {
+                        sensorJson["PeakReadingTime"] = timestamp;
+                    }
+                }
+            }
+        }
+    }
+}
+
 /**
  * @brief Returns the Redfish State value for the specified inventory item.
  * @param inventoryItem D-Bus inventory item associated with a sensor.
@@ -519,11 +560,14 @@ inline void objectPropertiesToJson(
         bool available = true;
         std::optional<std::string> readingBasis;
         std::optional<std::string> implementation;
+        std::optional<Statistics> statistics;
+        std::optional<ReadingParameters> readingParameters;
 
         const bool success = sdbusplus::unpackPropertiesNoThrow(
             dbus_utils::UnpackErrorPrinter(), propertiesDict, "Available",
             checkAvailable, "ReadingBasis", readingBasis, "Implementation",
-            implementation);
+            implementation, "Readings", statistics, "ReadingParameters",
+            readingParameters);
         if (!success)
         {
             messages::internalError();
@@ -583,6 +627,8 @@ inline void objectPropertiesToJson(
                     sensorJson["Implementation"] = implementationOpt;
                 }
             }
+
+            updateSensorStatistics(sensorJson, statistics, readingParameters);
         }
         else if (sensorType == "temperature")
         {

test/redfish-core/include/utils/sensor_utils_test.cpp

@@ -2,7 +2,9 @@
 // SPDX-FileCopyrightText: Copyright OpenBMC Authors
 #include "utils/sensor_utils.hpp"
 
+#include <optional>
 #include <string>
+#include <tuple>
 
 #include <gtest/gtest.h>
 
@@ -112,5 +114,72 @@ TEST(IsExcerptNode, False)
     EXPECT_FALSE(isExcerptNode(ChassisSubNode::unknownNode));
 }
 
+TEST(UpdateSensorStatistics, ParametersValid)
+{
+    nlohmann::json sensorJson;
+    Reading reading =
+        std::make_tuple("metricId1", "metadata1", 42.5, 1234567890);
+    Readings metrics = {reading};
+    Statistics statistics = std::make_tuple(1234567890, metrics);
+    SensorPaths sensorPaths;
+    ReadingParameters readingParams = {std::make_tuple(
+        sensorPaths,
+        "xyz.openbmc_project.Telemetry.Report.OperationType.Maximum",
+        "metricId1", 60)};
+
+    updateSensorStatistics(sensorJson, statistics, readingParams);
+
+    EXPECT_EQ(sensorJson["PeakReading"], 42.5);
+    EXPECT_EQ(sensorJson["PeakReadingTime"], 1234567890);
+}
+
+TEST(UpdateSensorStatistics, EmptyMetrics)
+{
+    nlohmann::json sensorJson;
+    Readings metrics;
+    Statistics statistics = std::make_tuple(1234567890, metrics);
+    SensorPaths sensorPaths;
+    ReadingParameters readingParams = {std::make_tuple(
+        sensorPaths,
+        "xyz.openbmc_project.Telemetry.Report.OperationType.Maximum",
+        "metricId1", 60)};
+
+    updateSensorStatistics(sensorJson, statistics, readingParams);
+
+    EXPECT_FALSE(sensorJson.contains("PeakReading"));
+    EXPECT_FALSE(sensorJson.contains("PeakReadingTime"));
+}
+
+TEST(UpdateSensorStatistics, NonMaximumOperationType)
+{
+    nlohmann::json sensorJson;
+    Reading reading =
+        std::make_tuple("metricId1", "metadata1", 42.5, 1234567890);
+    Readings metrics = {reading};
+    Statistics statistics = std::make_tuple(1234567890, metrics);
+    SensorPaths sensorPaths;
+    ReadingParameters readingParams = {std::make_tuple(
+        sensorPaths,
+        "xyz.openbmc_project.Telemetry.Report.OperationType.Minimum",
+        "metricId1", 60)};
+
+    updateSensorStatistics(sensorJson, statistics, readingParams);
+
+    EXPECT_FALSE(sensorJson.contains("PeakReading"));
+    EXPECT_FALSE(sensorJson.contains("PeakReadingTime"));
+}
+
+TEST(UpdateSensorStatistics, ParamsNullopt)
+{
+    nlohmann::json sensorJson;
+    std::optional<Statistics> statistics = std::nullopt;
+    std::optional<ReadingParameters> readingParams = std::nullopt;
+
+    updateSensorStatistics(sensorJson, statistics, readingParams);
+
+    EXPECT_FALSE(sensorJson.contains("PeakReading"));
+    EXPECT_FALSE(sensorJson.contains("PeakReadingTime"));
+}
+
 } // namespace
 } // namespace redfish::sensor_utils