Fixed issue with wrong timestamp
Telemetry service used steady_clock for generating timestamps, but it
produced incorrect time. This change makes telemetry service use
steady_clock for intervals and system_clock for timestamps.
Changed readings timestamp to display current timestamp instead of a
time when reading was received.
Tested:
- correct timestamp is visible on dbus
- other telemetry service features are still working
Change-Id: Ic49f45640532cfffaeff5e0bd5591e6d99e5def5
Signed-off-by: Krzysztof Grobelny <krzysztof.grobelny@intel.com>
diff --git a/src/details/collection_function.cpp b/src/details/collection_function.cpp
index d92fdf3..360f082 100644
--- a/src/details/collection_function.cpp
+++ b/src/details/collection_function.cpp
@@ -8,101 +8,105 @@
class FunctionSingle : public CollectionFunction
{
public:
- ReadingItem calculate(const std::vector<ReadingItem>& readings,
- uint64_t) const override
+ double calculate(const std::vector<ReadingItem>& readings,
+ Milliseconds) const override
{
- return readings.back();
+ return readings.back().second;
}
- ReadingItem calculateForStartupInterval(std::vector<ReadingItem>& readings,
- uint64_t timestamp) const override
+ double calculateForStartupInterval(std::vector<ReadingItem>& readings,
+ Milliseconds) const override
{
readings.assign({readings.back()});
- return readings.back();
+ return readings.back().second;
}
};
class FunctionMinimum : public CollectionFunction
{
public:
- ReadingItem calculate(const std::vector<ReadingItem>& readings,
- uint64_t) const override
+ double calculate(const std::vector<ReadingItem>& readings,
+ Milliseconds) const override
{
- return *std::min_element(
- readings.begin(), readings.end(),
- [](const auto& left, const auto& right) {
- return std::make_tuple(!std::isfinite(left.second),
- left.second) <
- std::make_tuple(!std::isfinite(right.second),
- right.second);
- });
+ return std::min_element(
+ readings.begin(), readings.end(),
+ [](const auto& left, const auto& right) {
+ return std::make_tuple(!std::isfinite(left.second),
+ left.second) <
+ std::make_tuple(!std::isfinite(right.second),
+ right.second);
+ })
+ ->second;
}
- ReadingItem calculateForStartupInterval(std::vector<ReadingItem>& readings,
- uint64_t timestamp) const override
+ double calculateForStartupInterval(std::vector<ReadingItem>& readings,
+ Milliseconds timestamp) const override
{
- readings.assign({ReadingItem(calculate(readings, timestamp))});
- return readings.back();
+ readings.assign(
+ {ReadingItem(timestamp, calculate(readings, timestamp))});
+ return readings.back().second;
}
};
class FunctionMaximum : public CollectionFunction
{
public:
- ReadingItem calculate(const std::vector<ReadingItem>& readings,
- uint64_t) const override
+ double calculate(const std::vector<ReadingItem>& readings,
+ Milliseconds) const override
{
- return *std::max_element(
- readings.begin(), readings.end(),
- [](const auto& left, const auto& right) {
- return std::make_tuple(std::isfinite(left.second),
- left.second) <
- std::make_tuple(std::isfinite(right.second),
- right.second);
- });
+ return std::max_element(
+ readings.begin(), readings.end(),
+ [](const auto& left, const auto& right) {
+ return std::make_tuple(std::isfinite(left.second),
+ left.second) <
+ std::make_tuple(std::isfinite(right.second),
+ right.second);
+ })
+ ->second;
}
- ReadingItem calculateForStartupInterval(std::vector<ReadingItem>& readings,
- uint64_t timestamp) const override
+ double calculateForStartupInterval(std::vector<ReadingItem>& readings,
+ Milliseconds timestamp) const override
{
- readings.assign({ReadingItem(calculate(readings, timestamp))});
- return readings.back();
+ readings.assign(
+ {ReadingItem(timestamp, calculate(readings, timestamp))});
+ return readings.back().second;
}
};
class FunctionAverage : public CollectionFunction
{
public:
- ReadingItem calculate(const std::vector<ReadingItem>& readings,
- uint64_t timestamp) const override
+ double calculate(const std::vector<ReadingItem>& readings,
+ Milliseconds timestamp) const override
{
auto valueSum = 0.0;
- auto timeSum = uint64_t{0};
+ auto timeSum = Milliseconds{0};
for (auto it = readings.begin(); it != std::prev(readings.end()); ++it)
{
if (std::isfinite(it->second))
{
const auto kt = std::next(it);
const auto duration = kt->first - it->first;
- valueSum += it->second * duration;
+ valueSum += it->second * duration.count();
timeSum += duration;
}
}
const auto duration = timestamp - readings.back().first;
- valueSum += readings.back().second * duration;
+ valueSum += readings.back().second * duration.count();
timeSum += duration;
- return ReadingItem{timestamp, valueSum / timeSum};
+ return valueSum / std::max(timeSum.count(), uint64_t{1u});
}
- ReadingItem calculateForStartupInterval(std::vector<ReadingItem>& readings,
- uint64_t timestamp) const override
+ double calculateForStartupInterval(std::vector<ReadingItem>& readings,
+ Milliseconds timestamp) const override
{
auto result = calculate(readings, timestamp);
- if (std::isfinite(result.second))
+ if (std::isfinite(result))
{
- readings.assign({ReadingItem(readings.front().first, result.second),
+ readings.assign({ReadingItem(readings.front().first, result),
ReadingItem(timestamp, readings.back().second)});
}
return result;
@@ -111,9 +115,11 @@
class FunctionSummation : public CollectionFunction
{
+ using Multiplier = std::chrono::duration<double>;
+
public:
- ReadingItem calculate(const std::vector<ReadingItem>& readings,
- uint64_t timestamp) const override
+ double calculate(const std::vector<ReadingItem>& readings,
+ const Milliseconds timestamp) const override
{
auto valueSum = 0.0;
for (auto it = readings.begin(); it != std::prev(readings.end()); ++it)
@@ -121,28 +127,45 @@
if (std::isfinite(it->second))
{
const auto kt = std::next(it);
- const auto duration = kt->first - it->first;
- valueSum += it->second * duration;
+ const auto multiplier =
+ calculateMultiplier(kt->first - it->first);
+ valueSum += it->second * multiplier.count();
}
}
- const auto duration = timestamp - readings.back().first;
- valueSum += readings.back().second * duration;
+ const auto multiplier =
+ calculateMultiplier(timestamp - readings.back().first);
+ valueSum += readings.back().second * multiplier.count();
- return ReadingItem{timestamp, valueSum};
+ return valueSum;
}
- ReadingItem calculateForStartupInterval(std::vector<ReadingItem>& readings,
- uint64_t timestamp) const override
+ double
+ calculateForStartupInterval(std::vector<ReadingItem>& readings,
+ const Milliseconds timestamp) const override
{
- auto result = calculate(readings, timestamp);
- if (std::isfinite(result.second) && timestamp > 0u)
+ const auto result = calculate(readings, timestamp);
+ if (readings.size() > 2 && std::isfinite(result))
{
- readings.assign({ReadingItem(timestamp - 1u, result.second),
- ReadingItem(timestamp, readings.back().second)});
+ const auto multiplier =
+ calculateMultiplier(timestamp - readings.front().first).count();
+ if (multiplier > 0.)
+ {
+ const auto prevValue = result / multiplier;
+ readings.assign(
+ {ReadingItem(readings.front().first, prevValue),
+ ReadingItem(timestamp, readings.back().second)});
+ }
}
return result;
}
+
+ private:
+ static constexpr Multiplier calculateMultiplier(Milliseconds duration)
+ {
+ constexpr auto m = Multiplier{Seconds{1}};
+ return Multiplier{duration / m};
+ }
};
std::shared_ptr<CollectionFunction>