diff --git a/.gitignore b/.gitignore
index 6ea24d5..d5e4365 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 build/
+.obj/
 xyz.openbmc_project.Telemetry.service
 telemetry
 __pycache__
diff --git a/src/interfaces/metric.hpp b/src/interfaces/metric.hpp
index 57a2b68..4e2fae3 100644
--- a/src/interfaces/metric.hpp
+++ b/src/interfaces/metric.hpp
@@ -19,6 +19,7 @@
     virtual void deinitialize() = 0;
     virtual std::vector<MetricValue> getReadings() const = 0;
     virtual LabeledMetricParameters dumpConfiguration() const = 0;
+    virtual uint64_t sensorCount() const = 0;
 };
 
 } // namespace interfaces
diff --git a/src/interfaces/report_factory.hpp b/src/interfaces/report_factory.hpp
index 970dd01..36fc589 100644
--- a/src/interfaces/report_factory.hpp
+++ b/src/interfaces/report_factory.hpp
@@ -26,7 +26,8 @@
     virtual std::unique_ptr<interfaces::Report>
         make(const std::string& name, const std::string& reportingType,
              bool emitsReadingsSignal, bool logToMetricReportsCollection,
-             Milliseconds period, ReportManager& reportManager,
+             Milliseconds period, uint64_t appendLimit,
+             const std::string& reportUpdates, ReportManager& reportManager,
              JsonStorage& reportStorage,
              std::vector<LabeledMetricParameters> labeledMetricParams,
              bool enabled) const = 0;
diff --git a/src/metric.cpp b/src/metric.cpp
index 4290293..d76f220 100644
--- a/src/metric.cpp
+++ b/src/metric.cpp
@@ -234,6 +234,11 @@
     return result;
 }
 
+uint64_t Metric::sensorCount() const
+{
+    return sensors.size();
+}
+
 void Metric::attemptUnpackJsonMetadata()
 {
     using MetricMetadata =
diff --git a/src/metric.hpp b/src/metric.hpp
index f053691..7929aac 100644
--- a/src/metric.hpp
+++ b/src/metric.hpp
@@ -22,6 +22,7 @@
     void sensorUpdated(interfaces::Sensor&, uint64_t) override;
     void sensorUpdated(interfaces::Sensor&, uint64_t, double value) override;
     LabeledMetricParameters dumpConfiguration() const override;
+    uint64_t sensorCount() const override;
 
   private:
     class CollectionData;
diff --git a/src/report.cpp b/src/report.cpp
index af19a91..8c01cf2 100644
--- a/src/report.cpp
+++ b/src/report.cpp
@@ -6,15 +6,17 @@
 #include <phosphor-logging/log.hpp>
 #include <sdbusplus/vtable.hpp>
 
+#include <limits>
 #include <numeric>
 
 Report::Report(boost::asio::io_context& ioc,
                const std::shared_ptr<sdbusplus::asio::object_server>& objServer,
                const std::string& reportName,
-               const std::string& reportingTypeIn,
+               const ReportingType reportingTypeIn,
                const bool emitsReadingsUpdateIn,
                const bool logToMetricReportsCollectionIn,
-               const Milliseconds intervalIn,
+               const Milliseconds intervalIn, const uint64_t appendLimitIn,
+               const ReportUpdates reportUpdatesIn,
                interfaces::ReportManager& reportManager,
                interfaces::JsonStorage& reportStorageIn,
                std::vector<std::shared_ptr<interfaces::Metric>> metricsIn,
@@ -23,6 +25,10 @@
     path(reportDir + name), reportingType(reportingTypeIn),
     interval(intervalIn), emitsReadingsUpdate(emitsReadingsUpdateIn),
     logToMetricReportsCollection(logToMetricReportsCollectionIn),
+    sensorCount(getSensorCount(metricsIn)),
+    appendLimit(deduceAppendLimit(appendLimitIn)),
+    reportUpdates(reportUpdatesIn),
+    readingsBuffer(deduceBufferSize(reportUpdates, reportingType)),
     objServer(objServer), metrics(std::move(metricsIn)), timer(ioc),
     fileName(std::to_string(std::hash<std::string>{}(name))),
     reportStorage(reportStorageIn), enabled(enabledIn)
@@ -55,7 +61,7 @@
     persistency = storeConfiguration();
     reportIface = makeReportInterface();
 
-    if (reportingType == "Periodic")
+    if (reportingType == ReportingType::Periodic)
     {
         scheduleTimer(interval);
     }
@@ -69,6 +75,58 @@
     }
 }
 
+uint64_t Report::getSensorCount(
+    std::vector<std::shared_ptr<interfaces::Metric>>& metrics)
+{
+    uint64_t sensorCount = 0;
+    for (auto& metric : metrics)
+    {
+        sensorCount += metric->sensorCount();
+    }
+    return sensorCount;
+}
+
+uint64_t Report::deduceAppendLimit(const uint64_t appendLimitIn) const
+{
+    if (appendLimitIn == std::numeric_limits<uint64_t>::max())
+    {
+        return sensorCount;
+    }
+    else
+    {
+        return appendLimitIn;
+    }
+}
+
+uint64_t Report::deduceBufferSize(const ReportUpdates reportUpdatesIn,
+                                  const ReportingType reportingTypeIn) const
+{
+    if (reportUpdatesIn == ReportUpdates::Overwrite ||
+        reportingTypeIn == ReportingType::OnRequest)
+    {
+        return sensorCount;
+    }
+    else
+    {
+        return appendLimit;
+    }
+}
+
+void Report::setReportUpdates(const ReportUpdates newReportUpdates)
+{
+    if (reportUpdates != newReportUpdates)
+    {
+        if (reportingType != ReportingType::OnRequest &&
+            (reportUpdates == ReportUpdates::Overwrite ||
+             newReportUpdates == ReportUpdates::Overwrite))
+        {
+            readingsBuffer.clearAndResize(
+                deduceBufferSize(newReportUpdates, reportingType));
+        }
+        reportUpdates = newReportUpdates;
+    }
+}
+
 std::unique_ptr<sdbusplus::asio::dbus_interface> Report::makeReportInterface()
 {
     auto dbusIface = objServer->add_unique_interface(path, reportIfaceName);
@@ -77,7 +135,7 @@
         [this](bool newVal, const auto&) {
             if (newVal != enabled)
             {
-                if (true == newVal && "Periodic" == reportingType)
+                if (true == newVal && ReportingType::Periodic == reportingType)
                 {
                     scheduleTimer(interval);
                 }
@@ -147,8 +205,8 @@
     dbusIface->register_property_r("Readings", readings, readingsFlag,
                                    [this](const auto&) { return readings; });
     dbusIface->register_property_r(
-        "ReportingType", reportingType, sdbusplus::vtable::property_::const_,
-        [this](const auto&) { return reportingType; });
+        "ReportingType", std::string(), sdbusplus::vtable::property_::const_,
+        [this](const auto&) { return reportingTypeToString(reportingType); });
     dbusIface->register_property_r(
         "ReadingParameters", readingParametersPastVersion,
         sdbusplus::vtable::property_::const_,
@@ -165,8 +223,21 @@
         "LogToMetricReportsCollection", logToMetricReportsCollection,
         sdbusplus::vtable::property_::const_,
         [this](const auto&) { return logToMetricReportsCollection; });
+    dbusIface->register_property_r("AppendLimit", appendLimit,
+                                   sdbusplus::vtable::property_::emits_change,
+                                   [this](const auto&) { return appendLimit; });
+    dbusIface->register_property_rw(
+        "ReportUpdates", std::string(),
+        sdbusplus::vtable::property_::emits_change,
+        [this](auto newVal, auto& oldVal) {
+            ReportManager::verifyReportUpdates(newVal);
+            setReportUpdates(stringToReportUpdates(newVal));
+            oldVal = newVal;
+            return true;
+        },
+        [this](const auto&) { return reportUpdatesToString(reportUpdates); });
     dbusIface->register_method("Update", [this] {
-        if (reportingType == "OnRequest")
+        if (reportingType == ReportingType::OnRequest)
         {
             updateReadings();
         }
@@ -201,20 +272,33 @@
         return;
     }
 
-    using ReadingsTimestamp = std::tuple_element_t<0, Readings>;
-    using ReadingsValue = std::tuple_element_t<1, Readings>;
+    if (reportUpdates == ReportUpdates::Overwrite ||
+        reportingType == ReportingType::OnRequest)
+    {
+        readingsBuffer.clear();
+    }
 
-    std::get<ReadingsValue>(cachedReadings).clear();
     for (const auto& metric : metrics)
     {
-        for (const auto& [id, meta, val, timestamp] : metric->getReadings())
+        for (const auto& [id, metadata, value, timestamp] :
+             metric->getReadings())
         {
-            std::get<ReadingsValue>(cachedReadings)
-                .emplace_back(id, meta, val, timestamp);
+            if (reportUpdates == ReportUpdates::AppendStopsWhenFull &&
+                readingsBuffer.isFull())
+            {
+                enabled = false;
+                for (auto& metric : metrics)
+                {
+                    metric->deinitialize();
+                }
+                break;
+            }
+            readingsBuffer.emplace(id, metadata, value, timestamp);
         }
     }
-    std::get<ReadingsTimestamp>(cachedReadings) = std::time(0);
-    std::swap(readings, cachedReadings);
+
+    readings = {std::time(0), std::vector<ReadingData>(readingsBuffer.begin(),
+                                                       readingsBuffer.end())};
 
     reportIface->signal_property("Readings");
 }
@@ -228,10 +312,12 @@
         data["Enabled"] = enabled;
         data["Version"] = reportVersion;
         data["Name"] = name;
-        data["ReportingType"] = reportingType;
+        data["ReportingType"] = reportingTypeToString(reportingType);
         data["EmitsReadingsUpdate"] = emitsReadingsUpdate;
         data["LogToMetricReportsCollection"] = logToMetricReportsCollection;
         data["Interval"] = interval.count();
+        data["AppendLimit"] = appendLimit;
+        data["ReportUpdates"] = reportUpdatesToString(reportUpdates);
         data["ReadingParameters"] =
             utils::transform(metrics, [](const auto& metric) {
                 return metric->dumpConfiguration();
diff --git a/src/report.hpp b/src/report.hpp
index 18574cf..c758988 100644
--- a/src/report.hpp
+++ b/src/report.hpp
@@ -5,6 +5,7 @@
 #include "interfaces/report.hpp"
 #include "interfaces/report_manager.hpp"
 #include "types/report_types.hpp"
+#include "utils/circular_vector.hpp"
 
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/steady_timer.hpp>
@@ -18,9 +19,10 @@
   public:
     Report(boost::asio::io_context& ioc,
            const std::shared_ptr<sdbusplus::asio::object_server>& objServer,
-           const std::string& reportName, const std::string& reportingType,
+           const std::string& reportName, const ReportingType reportingType,
            const bool emitsReadingsSignal,
            const bool logToMetricReportsCollection, const Milliseconds period,
+           const uint64_t appendLimitIn, const ReportUpdates reportUpdatesIn,
            interfaces::ReportManager& reportManager,
            interfaces::JsonStorage& reportStorage,
            std::vector<std::shared_ptr<interfaces::Metric>> metrics,
@@ -49,17 +51,26 @@
     std::unique_ptr<sdbusplus::asio::dbus_interface> makeReportInterface();
     static void timerProc(boost::system::error_code, Report& self);
     void scheduleTimer(Milliseconds interval);
+    uint64_t deduceAppendLimit(const uint64_t appendLimitIn) const;
+    uint64_t deduceBufferSize(const ReportUpdates reportUpdatesIn,
+                              const ReportingType reportingTypeIn) const;
+    void setReportUpdates(const ReportUpdates newReportUpdates);
+    static uint64_t getSensorCount(
+        std::vector<std::shared_ptr<interfaces::Metric>>& metrics);
 
     std::string name;
     std::string path;
-    std::string reportingType;
+    ReportingType reportingType;
     Milliseconds interval;
     bool emitsReadingsUpdate;
     bool logToMetricReportsCollection;
     ReadingParametersPastVersion readingParametersPastVersion;
     ReadingParameters readingParameters;
     bool persistency = false;
-    Readings cachedReadings = {};
+    uint64_t sensorCount;
+    uint64_t appendLimit;
+    ReportUpdates reportUpdates;
+    CircularVector<ReadingData> readingsBuffer;
     Readings readings = {};
     std::shared_ptr<sdbusplus::asio::object_server> objServer;
     std::unique_ptr<sdbusplus::asio::dbus_interface> reportIface;
diff --git a/src/report_factory.cpp b/src/report_factory.cpp
index 3d86521..6c61cbe 100644
--- a/src/report_factory.cpp
+++ b/src/report_factory.cpp
@@ -17,9 +17,11 @@
 {}
 
 std::unique_ptr<interfaces::Report> ReportFactory::make(
-    const std::string& name, const std::string& reportingType,
+    const std::string& name, const std::string& reportingTypeStr,
     bool emitsReadingsSignal, bool logToMetricReportsCollection,
-    Milliseconds period, interfaces::ReportManager& reportManager,
+    Milliseconds period, uint64_t appendLimit,
+    const std::string& reportUpdatesStr,
+    interfaces::ReportManager& reportManager,
     interfaces::JsonStorage& reportStorage,
     std::vector<LabeledMetricParameters> labeledMetricParams,
     bool enabled) const
@@ -39,10 +41,14 @@
                 std::make_unique<Clock>());
         });
 
-    return std::make_unique<Report>(
-        bus->get_io_context(), objServer, name, reportingType,
-        emitsReadingsSignal, logToMetricReportsCollection, period,
-        reportManager, reportStorage, std::move(metrics), enabled);
+    const ReportingType reportingType = stringToReportingType(reportingTypeStr);
+    const ReportUpdates reportUpdates = stringToReportUpdates(reportUpdatesStr);
+
+    return std::make_unique<Report>(bus->get_io_context(), objServer, name,
+                                    reportingType, emitsReadingsSignal,
+                                    logToMetricReportsCollection, period,
+                                    appendLimit, reportUpdates, reportManager,
+                                    reportStorage, std::move(metrics), enabled);
 }
 
 Sensors ReportFactory::getSensors(
diff --git a/src/report_factory.hpp b/src/report_factory.hpp
index 69f6349..9f68972 100644
--- a/src/report_factory.hpp
+++ b/src/report_factory.hpp
@@ -22,7 +22,9 @@
     std::unique_ptr<interfaces::Report>
         make(const std::string& name, const std::string& reportingType,
              bool emitsReadingsSignal, bool logToMetricReportsCollection,
-             Milliseconds period, interfaces::ReportManager& reportManager,
+             Milliseconds period, uint64_t appendLimitIn,
+             const std::string& reportUpdatesIn,
+             interfaces::ReportManager& reportManager,
              interfaces::JsonStorage& reportStorage,
              std::vector<LabeledMetricParameters> labeledMetricParams,
              bool enabled) const override;
diff --git a/src/report_manager.cpp b/src/report_manager.cpp
index 64c587e..21a9736 100644
--- a/src/report_manager.cpp
+++ b/src/report_manager.cpp
@@ -57,31 +57,39 @@
                                     const uint64_t interval,
                                     ReadingParametersPastVersion metricParams) {
                     constexpr auto enabledDefault = true;
-                    return addReport(yield, reportName, reportingType,
-                                     emitsReadingsUpdate,
-                                     logToMetricReportsCollection,
-                                     Milliseconds(interval),
-                                     convertToReadingParameters(
-                                         std::move(metricParams)),
-                                     enabledDefault)
+                    constexpr uint64_t appendLimitDefault = 0;
+                    constexpr ReportUpdates reportUpdatesDefault =
+                        ReportUpdates::Overwrite;
+                    return addReport(
+                               yield, reportName, reportingType,
+                               emitsReadingsUpdate,
+                               logToMetricReportsCollection,
+                               Milliseconds(interval), appendLimitDefault,
+                               reportUpdatesToString(reportUpdatesDefault),
+                               convertToReadingParameters(
+                                   std::move(metricParams)),
+                               enabledDefault)
                         .getPath();
                 });
 
             dbusIface.register_method(
                 "AddReportFutureVersion",
-                [this](boost::asio::yield_context& yield,
-                       const std::string& reportName,
-                       const std::string& reportingType,
-                       const bool emitsReadingsUpdate,
-                       const bool logToMetricReportsCollection,
-                       const uint64_t interval,
-                       ReadingParameters metricParams) {
+
+                [this](
+                    boost::asio::yield_context& yield,
+                    const std::string& reportName,
+                    const std::string& reportingType,
+                    const std::string& reportUpdates,
+                    const uint64_t appendLimit, const bool emitsReadingsUpdate,
+                    const bool logToMetricReportsCollection,
+                    const uint64_t interval, ReadingParameters metricParams) {
                     constexpr auto enabledDefault = true;
                     return addReport(yield, reportName, reportingType,
                                      emitsReadingsUpdate,
                                      logToMetricReportsCollection,
-                                     Milliseconds(interval),
-                                     std::move(metricParams), enabledDefault)
+                                     Milliseconds(interval), appendLimit,
+                                     reportUpdates, std::move(metricParams),
+                                     enabledDefault)
                         .getPath();
                 });
         });
@@ -107,7 +115,7 @@
 
 void ReportManager::verifyAddReport(
     const std::string& reportName, const std::string& reportingType,
-    Milliseconds interval,
+    Milliseconds interval, const std::string& reportUpdates,
     const std::vector<LabeledMetricParameters>& readingParams)
 {
     if (reports.size() >= maxReports)
@@ -128,15 +136,16 @@
         }
     }
 
-    auto found = std::find(supportedReportingType.begin(),
-                           supportedReportingType.end(), reportingType);
-    if (found == supportedReportingType.end())
+    if (std::find(supportedReportingType.begin(), supportedReportingType.end(),
+                  reportingType) == supportedReportingType.end())
     {
         throw sdbusplus::exception::SdBusError(
             static_cast<int>(std::errc::invalid_argument),
             "Invalid reportingType");
     }
 
+    verifyReportUpdates(reportUpdates);
+
     if (reportingType == "Periodic" && interval < minInterval)
     {
         throw sdbusplus::exception::SdBusError(
@@ -172,29 +181,32 @@
     boost::asio::yield_context& yield, const std::string& reportName,
     const std::string& reportingType, const bool emitsReadingsUpdate,
     const bool logToMetricReportsCollection, Milliseconds interval,
+    const uint64_t appendLimit, const std::string& reportUpdates,
     ReadingParameters metricParams, const bool enabled)
 {
     auto labeledMetricParams =
         reportFactory->convertMetricParams(yield, metricParams);
 
     return addReport(reportName, reportingType, emitsReadingsUpdate,
-                     logToMetricReportsCollection, interval,
-                     std::move(labeledMetricParams), enabled);
+                     logToMetricReportsCollection, interval, appendLimit,
+                     reportUpdates, std::move(labeledMetricParams), enabled);
 }
 
 interfaces::Report& ReportManager::addReport(
     const std::string& reportName, const std::string& reportingType,
     const bool emitsReadingsUpdate, const bool logToMetricReportsCollection,
-    Milliseconds interval,
+    Milliseconds interval, const uint64_t appendLimit,
+    const std::string& reportUpdates,
     std::vector<LabeledMetricParameters> labeledMetricParams,
     const bool enabled)
 {
-    verifyAddReport(reportName, reportingType, interval, labeledMetricParams);
+    verifyAddReport(reportName, reportingType, interval, reportUpdates,
+                    labeledMetricParams);
 
-    reports.emplace_back(
-        reportFactory->make(reportName, reportingType, emitsReadingsUpdate,
-                            logToMetricReportsCollection, interval, *this,
-                            *reportStorage, labeledMetricParams, enabled));
+    reports.emplace_back(reportFactory->make(
+        reportName, reportingType, emitsReadingsUpdate,
+        logToMetricReportsCollection, interval, appendLimit, reportUpdates,
+        *this, *reportStorage, labeledMetricParams, enabled));
     return *reports.back();
 }
 
@@ -222,13 +234,17 @@
             bool logToMetricReportsCollection =
                 data->at("LogToMetricReportsCollection").get<bool>();
             uint64_t interval = data->at("Interval").get<uint64_t>();
+            uint64_t appendLimit = data->at("AppendLimit").get<uint64_t>();
+            std::string reportUpdates =
+                data->at("ReportUpdates").get<std::string>();
             auto readingParameters =
                 data->at("ReadingParameters")
                     .get<std::vector<LabeledMetricParameters>>();
 
             addReport(name, reportingType, emitsReadingsSignal,
                       logToMetricReportsCollection, Milliseconds(interval),
-                      std::move(readingParameters), enabled);
+                      appendLimit, reportUpdates, std::move(readingParameters),
+                      enabled);
         }
         catch (const std::exception& e)
         {
@@ -254,3 +270,14 @@
         }
     }
 }
+
+void ReportManager::verifyReportUpdates(const std::string& reportUpdates)
+{
+    if (std::find(supportedReportUpdates.begin(), supportedReportUpdates.end(),
+                  reportUpdates) == supportedReportUpdates.end())
+    {
+        throw sdbusplus::exception::SdBusError(
+            static_cast<int>(std::errc::invalid_argument),
+            "Invalid ReportUpdates");
+    }
+}
diff --git a/src/report_manager.hpp b/src/report_manager.hpp
index 9c21c5d..32118c2 100644
--- a/src/report_manager.hpp
+++ b/src/report_manager.hpp
@@ -42,17 +42,19 @@
     void verifyReportNameLength(const std::string& reportName);
     void verifyAddReport(
         const std::string& reportName, const std::string& reportingType,
-        Milliseconds interval,
+        Milliseconds interval, const std::string& reportUpdates,
         const std::vector<LabeledMetricParameters>& readingParams);
     interfaces::Report& addReport(
         boost::asio::yield_context& yield, const std::string& reportName,
         const std::string& reportingType, const bool emitsReadingsUpdate,
         const bool logToMetricReportsCollection, Milliseconds interval,
+        const uint64_t appendLimit, const std::string& reportUpdates,
         ReadingParameters metricParams, const bool enabled);
     interfaces::Report& addReport(
         const std::string& reportName, const std::string& reportingType,
         const bool emitsReadingsUpdate, const bool logToMetricReportsCollection,
-        Milliseconds interval,
+        Milliseconds interval, const uint64_t appendLimit,
+        const std::string& reportUpdates,
         std::vector<LabeledMetricParameters> metricParams, const bool enabled);
     void loadFromPersistent();
 
@@ -69,4 +71,8 @@
         "/xyz/openbmc_project/Telemetry/Reports";
     static constexpr std::array<std::string_view, 2> supportedReportingType = {
         "Periodic", "OnRequest"};
+    static constexpr std::array<std::string_view, 3> supportedReportUpdates = {
+        "Overwrite", "AppendStopsWhenFull", "AppendWrapsWhenFull"};
+
+    static void verifyReportUpdates(const std::string& reportUpdates);
 };
diff --git a/src/sensor_cache.hpp b/src/sensor_cache.hpp
index 3e19721..bebc4c6 100644
--- a/src/sensor_cache.hpp
+++ b/src/sensor_cache.hpp
@@ -5,7 +5,6 @@
 #include <boost/container/flat_map.hpp>
 #include <boost/system/error_code.hpp>
 
-#include <iostream>
 #include <memory>
 #include <string_view>
 
diff --git a/src/types/report_types.hpp b/src/types/report_types.hpp
index 8046df0..b0b1a69 100644
--- a/src/types/report_types.hpp
+++ b/src/types/report_types.hpp
@@ -33,9 +33,67 @@
     utils::tstring::Id, utils::tstring::MetricMetadata,
     utils::tstring::CollectionTimeScope, utils::tstring::CollectionDuration>;
 
-using Readings = std::tuple<
-    uint64_t,
-    std::vector<std::tuple<std::string, std::string, double, uint64_t>>>;
+using ReadingData = std::tuple<std::string, std::string, double, uint64_t>;
+
+using Readings = std::tuple<uint64_t, std::vector<ReadingData>>;
 
 ReadingParameters
     toReadingParameters(const std::vector<LabeledMetricParameters>& labeled);
+
+enum class ReportUpdates
+{
+    Overwrite = 0,
+    AppendStopsWhenFull,
+    AppendWrapsWhenFull,
+    NewReport
+};
+
+namespace details
+{
+constexpr std::array<std::pair<std::string_view, ReportUpdates>, 5>
+    convDataReportUpdates = {
+        std::make_pair("Overwrite", ReportUpdates::Overwrite),
+        std::make_pair("AppendStopsWhenFull",
+                       ReportUpdates::AppendStopsWhenFull),
+        std::make_pair("AppendWrapsWhenFull",
+                       ReportUpdates::AppendWrapsWhenFull),
+        std::make_pair("NewReport", ReportUpdates::NewReport)};
+
+} // namespace details
+
+inline ReportUpdates stringToReportUpdates(const std::string& str)
+{
+    return utils::stringToEnum(details::convDataReportUpdates, str);
+}
+
+inline std::string reportUpdatesToString(ReportUpdates v)
+{
+    return std::string(utils::enumToString(details::convDataReportUpdates, v));
+}
+
+enum class ReportingType
+{
+    OnChange = 0,
+    OnRequest,
+    Periodic
+};
+
+namespace details
+{
+constexpr std::array<std::pair<std::string_view, ReportingType>, 3>
+    convDataReportingType = {
+        std::make_pair("OnChange", ReportingType::OnChange),
+        std::make_pair("OnRequest", ReportingType::OnRequest),
+        std::make_pair("Periodic", ReportingType::Periodic)};
+
+} // namespace details
+
+inline ReportingType stringToReportingType(const std::string& str)
+{
+    return utils::stringToEnum(details::convDataReportingType, str);
+}
+
+inline std::string reportingTypeToString(ReportingType v)
+{
+    return std::string(utils::enumToString(details::convDataReportingType, v));
+}
diff --git a/src/utils/circular_vector.hpp b/src/utils/circular_vector.hpp
new file mode 100644
index 0000000..55d3f29
--- /dev/null
+++ b/src/utils/circular_vector.hpp
@@ -0,0 +1,59 @@
+#include <vector>
+
+template <class T>
+class CircularVector
+{
+  public:
+    CircularVector(size_t maxSizeIn) : maxSize(maxSizeIn)
+    {}
+
+    template <class... Args>
+    void emplace(Args&&... args)
+    {
+        if (maxSize == 0)
+        {
+            return;
+        }
+        if (vec.size() == maxSize)
+        {
+            vec.at(idx) = T(std::forward<Args>(args)...);
+        }
+        else
+        {
+            vec.emplace_back(std::forward<Args>(args)...);
+        }
+        idx = (idx + 1) == maxSize ? 0 : (idx + 1);
+    }
+
+    void clear()
+    {
+        vec.clear();
+        idx = 0;
+    }
+
+    void clearAndResize(size_t newMaxSize)
+    {
+        clear();
+        maxSize = newMaxSize;
+    }
+
+    bool isFull() const
+    {
+        return vec.size() == maxSize;
+    }
+
+    typename std::vector<T>::const_iterator begin() const
+    {
+        return vec.begin();
+    }
+
+    typename std::vector<T>::const_iterator end() const
+    {
+        return vec.end();
+    }
+
+  private:
+    size_t maxSize = 0;
+    size_t idx = 0;
+    std::vector<T> vec;
+};
diff --git a/tests/src/mocks/metric_mock.hpp b/tests/src/mocks/metric_mock.hpp
index a105aa0..268b681 100644
--- a/tests/src/mocks/metric_mock.hpp
+++ b/tests/src/mocks/metric_mock.hpp
@@ -20,4 +20,9 @@
     MOCK_METHOD(std::vector<MetricValue>, getReadings, (), (const, override));
     MOCK_METHOD(LabeledMetricParameters, dumpConfiguration, (),
                 (const, override));
+
+    uint64_t sensorCount() const override
+    {
+        return getReadings().size();
+    }
 };
diff --git a/tests/src/mocks/report_factory_mock.hpp b/tests/src/mocks/report_factory_mock.hpp
index e456429..f593883 100644
--- a/tests/src/mocks/report_factory_mock.hpp
+++ b/tests/src/mocks/report_factory_mock.hpp
@@ -35,7 +35,8 @@
             .WillByDefault(
                 WithArgs<1>(Invoke(&ReportFactoryMock::convertToLabeled)));
 
-        ON_CALL(*this, make(A<const std::string&>(), _, _, _, _, _, _, _, _))
+        ON_CALL(*this,
+                make(A<const std::string&>(), _, _, _, _, _, _, _, _, _, _))
             .WillByDefault(WithArgs<0>(Invoke([](const std::string& name) {
                 return std::make_unique<NiceMock<ReportMock>>(name);
             })));
@@ -47,9 +48,9 @@
 
     MOCK_METHOD(std::unique_ptr<interfaces::Report>, make,
                 (const std::string&, const std::string&, bool, bool,
-                 Milliseconds, interfaces::ReportManager&,
-                 interfaces::JsonStorage&, std::vector<LabeledMetricParameters>,
-                 bool),
+                 Milliseconds, uint64_t, const std::string&,
+                 interfaces::ReportManager&, interfaces::JsonStorage&,
+                 std::vector<LabeledMetricParameters>, bool),
                 (const, override));
 
     auto& expectMake(
@@ -65,12 +66,13 @@
                 make(params.reportName(), params.reportingType(),
                      params.emitReadingUpdate(),
                      params.logToMetricReportCollection(), params.interval(),
-                     rm, js, params.metricParameters(), params.enabled()));
+                     params.appendLimit(), params.reportUpdates(), rm, js,
+                     params.metricParameters(), params.enabled()));
         }
         else
         {
             using testing::_;
-            return EXPECT_CALL(*this, make(_, _, _, _, _, rm, js, _, _));
+            return EXPECT_CALL(*this, make(_, _, _, _, _, _, _, rm, js, _, _));
         }
     }
 };
diff --git a/tests/src/params/report_params.hpp b/tests/src/params/report_params.hpp
index cc71ce3..d68f3fb 100644
--- a/tests/src/params/report_params.hpp
+++ b/tests/src/params/report_params.hpp
@@ -75,6 +75,28 @@
         return enabledProperty;
     }
 
+    ReportParams& appendLimit(uint64_t val)
+    {
+        appendLimitProperty = val;
+        return *this;
+    }
+
+    uint64_t appendLimit() const
+    {
+        return appendLimitProperty;
+    }
+
+    ReportParams& reportUpdates(std::string val)
+    {
+        reportUpdatesProperty = val;
+        return *this;
+    }
+
+    std::string reportUpdates() const
+    {
+        return reportUpdatesProperty;
+    }
+
     ReportParams& metricParameters(std::vector<LabeledMetricParameters> val)
     {
         metricParametersProperty = std::move(val);
@@ -92,6 +114,8 @@
     bool emitReadingUpdateProperty = true;
     bool logToMetricReportCollectionProperty = true;
     Milliseconds intervalProperty = ReportManager::minInterval;
+    uint64_t appendLimitProperty = 123;
+    std::string reportUpdatesProperty = "Overwrite";
     std::vector<LabeledMetricParameters> metricParametersProperty{
         {LabeledMetricParameters{
              {LabeledSensorParameters{"Service",
diff --git a/tests/src/test_report.cpp b/tests/src/test_report.cpp
index ccdcce8..f09ddef 100644
--- a/tests/src/test_report.cpp
+++ b/tests/src/test_report.cpp
@@ -68,9 +68,11 @@
 
         return std::make_unique<Report>(
             DbusEnvironment::getIoc(), DbusEnvironment::getObjServer(),
-            params.reportName(), params.reportingType(),
+            params.reportName(), stringToReportingType(params.reportingType()),
             params.emitReadingUpdate(), params.logToMetricReportCollection(),
-            params.interval(), *reportManagerMock, storageMock,
+            params.interval(), params.appendLimit(),
+            stringToReportUpdates(params.reportUpdates()), *reportManagerMock,
+            storageMock,
             utils::convContainer<std::shared_ptr<interfaces::Metric>>(
                 metricMocks),
             params.enabled());
@@ -125,6 +127,10 @@
     EXPECT_THAT(getProperty<bool>(sut->getPath(), "Persistency"), Eq(true));
     EXPECT_THAT(getProperty<bool>(sut->getPath(), "EmitsReadingsUpdate"),
                 Eq(defaultParams.emitReadingUpdate()));
+    EXPECT_THAT(getProperty<uint64_t>(sut->getPath(), "AppendLimit"),
+                Eq(defaultParams.appendLimit()));
+    EXPECT_THAT(getProperty<std::string>(sut->getPath(), "ReportUpdates"),
+                Eq(defaultParams.reportUpdates()));
     EXPECT_THAT(
         getProperty<bool>(sut->getPath(), "LogToMetricReportsCollection"),
         Eq(defaultParams.logToMetricReportCollection()));
@@ -503,6 +509,113 @@
                             std::make_tuple("aa"s, "bb"s, 42.0, 74u)));
 }
 
+struct ReportUpdatesReportParams
+{
+    ReportParams reportParams;
+    std::vector<ReadingData> expectedReadings;
+    bool expectedEnabled;
+};
+
+class TestReportWithReportUpdatesAndLimit :
+    public TestReport,
+    public WithParamInterface<ReportUpdatesReportParams>
+{
+    void SetUp() override
+    {
+        sut = makeReport(ReportParams(GetParam().reportParams)
+                             .reportingType("Periodic")
+                             .interval(std::chrono::hours(1000)));
+    }
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    _, TestReportWithReportUpdatesAndLimit,
+    Values(
+        ReportUpdatesReportParams{
+            ReportParams().reportUpdates("AppendWrapsWhenFull").appendLimit(5),
+            std::vector<ReadingData>{{std::make_tuple("aa"s, "bb"s, 42.0, 74u),
+                                      std::make_tuple("a"s, "b"s, 17.1, 114u),
+                                      std::make_tuple("aa"s, "bb"s, 42.0, 74u),
+                                      std::make_tuple("aa"s, "bb"s, 42.0, 74u),
+                                      std::make_tuple("a"s, "b"s, 17.1, 114u)}},
+            true},
+        ReportUpdatesReportParams{
+            ReportParams().reportUpdates("AppendWrapsWhenFull").appendLimit(4),
+            std::vector<ReadingData>{
+                {std::make_tuple("a"s, "b"s, 17.1, 114u),
+                 std::make_tuple("aa"s, "bb"s, 42.0, 74u),
+                 std::make_tuple("a"s, "b"s, 17.1, 114u),
+                 std::make_tuple("aa"s, "bb"s, 42.0, 74u)}},
+            true},
+        ReportUpdatesReportParams{
+            ReportParams().reportUpdates("AppendWrapsWhenFull").appendLimit(0),
+            std::vector<ReadingData>{}, true},
+        ReportUpdatesReportParams{
+            ReportParams().reportUpdates("AppendStopsWhenFull").appendLimit(10),
+            std::vector<ReadingData>{
+                {std::make_tuple("a"s, "b"s, 17.1, 114u),
+                 std::make_tuple("aa"s, "bb"s, 42.0, 74u),
+                 std::make_tuple("a"s, "b"s, 17.1, 114u),
+                 std::make_tuple("aa"s, "bb"s, 42.0, 74u),
+                 std::make_tuple("a"s, "b"s, 17.1, 114u),
+                 std::make_tuple("aa"s, "bb"s, 42.0, 74u),
+                 std::make_tuple("a"s, "b"s, 17.1, 114u),
+                 std::make_tuple("aa"s, "bb"s, 42.0, 74u)}},
+            true},
+        ReportUpdatesReportParams{
+            ReportParams().reportUpdates("AppendStopsWhenFull").appendLimit(5),
+            std::vector<ReadingData>{{std::make_tuple("a"s, "b"s, 17.1, 114u),
+                                      std::make_tuple("aa"s, "bb"s, 42.0, 74u),
+                                      std::make_tuple("a"s, "b"s, 17.1, 114u),
+                                      std::make_tuple("aa"s, "bb"s, 42.0, 74u),
+                                      std::make_tuple("a"s, "b"s, 17.1, 114u)}},
+            false},
+        ReportUpdatesReportParams{
+            ReportParams().reportUpdates("AppendStopsWhenFull").appendLimit(4),
+            std::vector<ReadingData>{
+                {std::make_tuple("a"s, "b"s, 17.1, 114u),
+                 std::make_tuple("aa"s, "bb"s, 42.0, 74u),
+                 std::make_tuple("a"s, "b"s, 17.1, 114u),
+                 std::make_tuple("aa"s, "bb"s, 42.0, 74u)}},
+            false},
+        ReportUpdatesReportParams{
+            ReportParams().reportUpdates("AppendStopsWhenFull").appendLimit(0),
+            std::vector<ReadingData>{}, false},
+        ReportUpdatesReportParams{
+            ReportParams().reportUpdates("Overwrite").appendLimit(500),
+            std::vector<ReadingData>{
+                {std::make_tuple("a"s, "b"s, 17.1, 114u),
+                 std::make_tuple("aa"s, "bb"s, 42.0, 74u)}},
+            true},
+        ReportUpdatesReportParams{
+            ReportParams().reportUpdates("Overwrite").appendLimit(1),
+            std::vector<ReadingData>{
+                {std::make_tuple("a"s, "b"s, 17.1, 114u),
+                 std::make_tuple("aa"s, "bb"s, 42.0, 74u)}},
+            true},
+        ReportUpdatesReportParams{
+            ReportParams().reportUpdates("Overwrite").appendLimit(0),
+            std::vector<ReadingData>{
+                {std::make_tuple("a"s, "b"s, 17.1, 114u),
+                 std::make_tuple("aa"s, "bb"s, 42.0, 74u)}},
+            true}));
+
+TEST_P(TestReportWithReportUpdatesAndLimit,
+       readingsAreUpdatedAfterIntervalExpires)
+{
+    for (int i = 0; i < 4; i++)
+    {
+        sut->updateReadings();
+    }
+
+    const auto [timestamp, readings] =
+        getProperty<Readings>(sut->getPath(), "Readings");
+    const auto enabled = getProperty<bool>(sut->getPath(), "Enabled");
+
+    EXPECT_THAT(readings, ElementsAreArray(GetParam().expectedReadings));
+    EXPECT_EQ(enabled, GetParam().expectedEnabled);
+}
+
 class TestReportInitialization : public TestReport
 {
   public:
@@ -593,3 +706,11 @@
     makeMonitor();
     DbusEnvironment::sleepFor(defaultParams.interval() * 2);
 }
+
+TEST_F(TestReportInitialization, appendLimitDeducedProperly)
+{
+    sut = makeReport(
+        ReportParams().appendLimit(std::numeric_limits<uint64_t>::max()));
+    auto appendLimit = getProperty<uint64_t>(sut->getPath(), "AppendLimit");
+    EXPECT_EQ(appendLimit, 2ull);
+}
diff --git a/tests/src/test_report_manager.cpp b/tests/src/test_report_manager.cpp
index eeedd96..a740d95 100644
--- a/tests/src/test_report_manager.cpp
+++ b/tests/src/test_report_manager.cpp
@@ -60,9 +60,9 @@
             },
             DbusEnvironment::serviceName(), ReportManager::reportManagerPath,
             ReportManager::reportManagerIfaceName, "AddReportFutureVersion",
-            params.reportName(), params.reportingType(),
-            params.emitReadingUpdate(), params.logToMetricReportCollection(),
-            params.interval().count(),
+            params.reportName(), params.reportingType(), params.reportUpdates(),
+            params.appendLimit(), params.emitReadingUpdate(),
+            params.logToMetricReportCollection(), params.interval().count(),
             toReadingParameters(params.metricParameters()));
         return DbusEnvironment::waitForFuture(addReportPromise.get_future());
     }
@@ -336,6 +336,8 @@
         {"LogToMetricReportsCollection",
          reportParams.logToMetricReportCollection()},
         {"Interval", reportParams.interval().count()},
+        {"ReportUpdates", reportParams.reportUpdates()},
+        {"AppendLimit", reportParams.appendLimit()},
         {"ReadingParameters", reportParams.metricParameters()}};
 };