xref: /openbmc/telemetry/src/report_manager.cpp (revision e6d4887453f0b23b46c012da7cb26f2beb38ef0e) 
1 #include "report_manager.hpp"
2 
3 #include "report.hpp"
4 #include "types/report_types.hpp"
5 #include "utils/conversion.hpp"
6 #include "utils/generate_id.hpp"
7 #include "utils/transform.hpp"
8 
9 #include <phosphor-logging/log.hpp>
10 #include <sdbusplus/exception.hpp>
11 
12 #include <stdexcept>
13 #include <system_error>
14 
15 ReadingParameters
16     convertToReadingParameters(ReadingParametersPastVersion params)
17 {
18     return utils::transform(params, [](const auto& param) {
19         using namespace std::chrono_literals;
20 
21         const auto& [sensorPath, operationType, id, metadata] = param;
22 
23         return ReadingParameters::value_type(
24             std::vector<
25                 std::tuple<sdbusplus::message::object_path, std::string>>{
26                 {sensorPath, metadata}},
27             operationType, id, utils::enumToString(CollectionTimeScope::point),
28             0u);
29     });
30 }
31 
32 ReportManager::ReportManager(
33     std::unique_ptr<interfaces::ReportFactory> reportFactoryIn,
34     std::unique_ptr<interfaces::JsonStorage> reportStorageIn,
35     const std::shared_ptr<sdbusplus::asio::object_server>& objServerIn) :
36     reportFactory(std::move(reportFactoryIn)),
37     reportStorage(std::move(reportStorageIn)), objServer(objServerIn)
38 {
39     reports.reserve(maxReports);
40 
41     loadFromPersistent();
42 
43     reportManagerIface = objServer->add_unique_interface(
44         reportManagerPath, reportManagerIfaceName, [this](auto& dbusIface) {
45             dbusIface.register_property_r(
46                 "MaxReports", size_t{}, sdbusplus::vtable::property_::const_,
47                 [](const auto&) { return maxReports; });
48             dbusIface.register_property_r(
49                 "MaxReportIdLength", size_t{},
50                 sdbusplus::vtable::property_::const_,
51                 [](const auto&) { return maxReportIdLength; });
52             dbusIface.register_property_r(
53                 "MinInterval", uint64_t{}, sdbusplus::vtable::property_::const_,
54                 [](const auto&) -> uint64_t { return minInterval.count(); });
55 
56             dbusIface.register_method(
57                 "AddReport", [this](boost::asio::yield_context& yield,
58                                     const std::string& reportId,
59                                     const std::string& reportingType,
60                                     const bool emitsReadingsUpdate,
61                                     const bool logToMetricReportsCollection,
62                                     const uint64_t interval,
63                                     ReadingParametersPastVersion metricParams) {
64                     constexpr auto enabledDefault = true;
65                     constexpr uint64_t appendLimitDefault = 0;
66                     constexpr ReportUpdates reportUpdatesDefault =
67                         ReportUpdates::overwrite;
68 
69                     std::vector<ReportAction> reportActions;
70 
71                     if (emitsReadingsUpdate)
72                     {
73                         reportActions.emplace_back(
74                             ReportAction::emitsReadingsUpdate);
75                     }
76                     if (logToMetricReportsCollection)
77                     {
78                         reportActions.emplace_back(
79                             ReportAction::logToMetricReportsCollection);
80                     }
81 
82                     return addReport(yield, reportId, reportId,
83                                      utils::toReportingType(reportingType),
84                                      reportActions, Milliseconds(interval),
85                                      appendLimitDefault, reportUpdatesDefault,
86                                      convertToReadingParameters(
87                                          std::move(metricParams)),
88                                      enabledDefault)
89                         .getPath();
90                 });
91 
92             dbusIface.register_method(
93                 "AddReportFutureVersion",
94                 [this](
95                     boost::asio::yield_context& yield,
96                     const std::string& reportId, const std::string& reportName,
97                     const std::string& reportingType,
98                     const std::string& reportUpdates,
99                     const uint64_t appendLimit,
100                     const std::vector<std::string>& reportActions,
101                     const uint64_t interval, ReadingParameters metricParams) {
102                     constexpr auto enabledDefault = true;
103                     return addReport(yield, reportId, reportName,
104                                      utils::toReportingType(reportingType),
105                                      utils::transform(
106                                          reportActions,
107                                          [](const auto& reportAction) {
108                                              return utils::toReportAction(
109                                                  reportAction);
110                                          }),
111                                      Milliseconds(interval), appendLimit,
112                                      utils::toReportUpdates(reportUpdates),
113                                      std::move(metricParams), enabledDefault)
114                         .getPath();
115                 });
116         });
117 }
118 
119 void ReportManager::removeReport(const interfaces::Report* report)
120 {
121     reports.erase(
122         std::remove_if(reports.begin(), reports.end(),
123                        [report](const auto& x) { return report == x.get(); }),
124         reports.end());
125 }
126 
127 void ReportManager::verifyAddReport(
128     const std::string& reportId, const std::string& reportName,
129     const ReportingType reportingType, Milliseconds interval,
130     const ReportUpdates reportUpdates, const uint64_t appendLimit,
131     const std::vector<LabeledMetricParameters>& readingParams)
132 {
133     if (reportingType == ReportingType::onChange)
134     {
135         throw sdbusplus::exception::SdBusError(
136             static_cast<int>(std::errc::invalid_argument),
137             "Invalid reportingType");
138     }
139 
140     if (reports.size() >= maxReports)
141     {
142         throw sdbusplus::exception::SdBusError(
143             static_cast<int>(std::errc::too_many_files_open),
144             "Reached maximal report count");
145     }
146 
147     if (appendLimit > maxAppendLimit &&
148         appendLimit != std::numeric_limits<uint64_t>::max())
149     {
150         throw sdbusplus::exception::SdBusError(
151             static_cast<int>(std::errc::invalid_argument),
152             "Append limit out of range");
153     }
154 
155     if (reportingType == ReportingType::periodic && interval < minInterval)
156     {
157         throw sdbusplus::exception::SdBusError(
158             static_cast<int>(std::errc::invalid_argument), "Invalid interval");
159     }
160 
161     size_t metricCount = 0;
162     for (auto metricParam : readingParams)
163     {
164         auto metricParamsVec =
165             metricParam.at_label<utils::tstring::SensorPath>();
166         metricCount += metricParamsVec.size();
167     }
168 
169     if (readingParams.size() > maxNumberMetrics ||
170         metricCount > maxNumberMetrics)
171     {
172         throw sdbusplus::exception::SdBusError(
173             static_cast<int>(std::errc::argument_list_too_long),
174             "Too many reading parameters");
175     }
176 
177     try
178     {
179         namespace ts = utils::tstring;
180 
181         for (const LabeledMetricParameters& item : readingParams)
182         {
183             utils::toOperationType(
184                 utils::toUnderlying(item.at_label<ts::OperationType>()));
185         }
186     }
187     catch (const std::exception& e)
188     {
189         throw sdbusplus::exception::SdBusError(
190             static_cast<int>(std::errc::invalid_argument), e.what());
191     }
192 }
193 
194 interfaces::Report& ReportManager::addReport(
195     boost::asio::yield_context& yield, const std::string& reportId,
196     const std::string& reportName, const ReportingType reportingType,
197     const std::vector<ReportAction>& reportActions, Milliseconds interval,
198     const uint64_t appendLimit, const ReportUpdates reportUpdates,
199     ReadingParameters metricParams, const bool enabled)
200 {
201     auto labeledMetricParams =
202         reportFactory->convertMetricParams(yield, metricParams);
203 
204     return addReport(reportId, reportName, reportingType, reportActions,
205                      interval, appendLimit, reportUpdates,
206                      std::move(labeledMetricParams), enabled);
207 }
208 
209 interfaces::Report& ReportManager::addReport(
210     const std::string& reportId, const std::string& reportName,
211     const ReportingType reportingType,
212     const std::vector<ReportAction>& reportActions, Milliseconds interval,
213     const uint64_t appendLimit, const ReportUpdates reportUpdates,
214     std::vector<LabeledMetricParameters> labeledMetricParams,
215     const bool enabled)
216 {
217     const auto existingReportIds = utils::transform(
218         reports, [](const auto& report) { return report->getId(); });
219 
220     auto [id, name] = utils::generateId(reportId, reportName, reportNameDefault,
221                                         existingReportIds, maxReportIdLength);
222 
223     verifyAddReport(id, name, reportingType, interval, reportUpdates,
224                     appendLimit, labeledMetricParams);
225 
226     reports.emplace_back(reportFactory->make(
227         id, name, reportingType, reportActions, interval, appendLimit,
228         reportUpdates, *this, *reportStorage, labeledMetricParams, enabled));
229     return *reports.back();
230 }
231 
232 void ReportManager::loadFromPersistent()
233 {
234     std::vector<interfaces::JsonStorage::FilePath> paths =
235         reportStorage->list();
236 
237     for (const auto& path : paths)
238     {
239         std::optional<nlohmann::json> data = reportStorage->load(path);
240         try
241         {
242             size_t version = data->at("Version").get<size_t>();
243             if (version != Report::reportVersion)
244             {
245                 throw std::logic_error("Invalid version");
246             }
247             bool enabled = data->at("Enabled").get<bool>();
248             std::string& id = data->at("Id").get_ref<std::string&>();
249             std::string& name = data->at("Name").get_ref<std::string&>();
250 
251             uint32_t reportingType = data->at("ReportingType").get<uint32_t>();
252             std::vector<ReportAction> reportActions = utils::transform(
253                 data->at("ReportActions").get<std::vector<uint32_t>>(),
254                 [](const auto reportAction) {
255                     return utils::toReportAction(reportAction);
256                 });
257             uint64_t interval = data->at("Interval").get<uint64_t>();
258             uint64_t appendLimit = data->at("AppendLimit").get<uint64_t>();
259             uint32_t reportUpdates = data->at("ReportUpdates").get<uint32_t>();
260             auto readingParameters =
261                 data->at("ReadingParameters")
262                     .get<std::vector<LabeledMetricParameters>>();
263 
264             addReport(id, name, utils::toReportingType(reportingType),
265                       reportActions, Milliseconds(interval), appendLimit,
266                       utils::toReportUpdates(reportUpdates),
267                       std::move(readingParameters), enabled);
268         }
269         catch (const std::exception& e)
270         {
271             phosphor::logging::log<phosphor::logging::level::ERR>(
272                 "Failed to load report from storage",
273                 phosphor::logging::entry(
274                     "FILENAME=%s",
275                     static_cast<std::filesystem::path>(path).c_str()),
276                 phosphor::logging::entry("EXCEPTION_MSG=%s", e.what()));
277             reportStorage->remove(path);
278         }
279     }
280 }
281