esp32_diagnostic_trace: add CircularDiagnosticBuffer class to improve design

Author: esp

examples/temperature-measurement-app/esp32/main/diagnostic-logs-provider-delegate-impl.cpp

@@ -81,7 +81,7 @@ size_t LogProvider::GetSizeForIntent(IntentEnum intent)
     {
     case IntentEnum::kEndUserSupport: {
 #if CONFIG_ENABLE_ESP_DIAGNOSTICS_TRACE
-        return DiagnosticStorageImpl::GetInstance().GetDataSize();
+        return CircularDiagnosticBuffer::GetInstance().GetDataSize();
 #else
         return static_cast<size_t>(endUserSupportLogEnd - endUserSupportLogStart);
 #endif
@@ -119,7 +119,7 @@ CHIP_ERROR LogProvider::PrepareLogContextForIntent(LogContext * context, IntentE
     {
     case IntentEnum::kEndUserSupport: {
 #if CONFIG_ENABLE_ESP_DIAGNOSTICS_TRACE
-        DiagnosticStorageImpl & diagnosticStorage = DiagnosticStorageImpl::GetInstance();
+        CircularDiagnosticBuffer & diagnosticStorage = CircularDiagnosticBuffer::GetInstance();
         MutableByteSpan endUserSupportSpan(endUserBuffer, CONFIG_END_USER_BUFFER_SIZE);
 
         if (diagnosticStorage.IsEmptyBuffer())

examples/temperature-measurement-app/esp32/main/main.cpp

@@ -88,7 +88,8 @@ extern "C" void app_main()
 #endif
 
 #if CONFIG_ENABLE_ESP_DIAGNOSTICS_TRACE
-    DiagnosticStorageImpl & diagnosticStorage = DiagnosticStorageImpl::GetInstance(endUserBuffer, CONFIG_END_USER_BUFFER_SIZE);
+    CircularDiagnosticBuffer & diagnosticStorage = CircularDiagnosticBuffer::GetInstance();
+    diagnosticStorage.Init(endUserBuffer, CONFIG_END_USER_BUFFER_SIZE);
     static ESP32Diagnostics diagnosticBackend(diagnosticStorage);
     Tracing::Register(diagnosticBackend);
 #endif

src/tracing/esp32_diagnostic_trace/BUILD.gn

@@ -27,7 +27,6 @@ static_library("backend") {
   sources = [
     "Counter.cpp",
     "Counter.h",
-    "DiagnosticStorageManager.cpp",
     "DiagnosticStorageManager.h",
     "DiagnosticTracing.cpp",
     "DiagnosticTracing.h",

src/tracing/esp32_diagnostic_trace/Counter.h

@@ -25,7 +25,6 @@
 #include <lib/support/CHIPMemString.h>
 #include <map>
 #include <string.h>
-#include <map>
 
 namespace chip {
 namespace Tracing {

src/tracing/esp32_diagnostic_trace/DiagnosticStorageManager.cpp

@@ -22,32 +22,127 @@
 #include <lib/support/CHIPMem.h>
 #include <tracing/esp32_diagnostic_trace/Diagnostics.h>
 
+#define TLV_CLOSING_BYTES 4
+
 namespace chip {
 namespace Tracing {
 namespace Diagnostics {
-class DiagnosticStorageImpl : public DiagnosticStorageInterface
+class CircularDiagnosticBuffer : public chip::TLV::TLVCircularBuffer, public DiagnosticStorageInterface
 {
 public:
-    static DiagnosticStorageImpl & GetInstance(uint8_t * buffer = nullptr, size_t bufferSize = 0);
+    // Singleton instance getter
+    static CircularDiagnosticBuffer & GetInstance()
+    {
+        static CircularDiagnosticBuffer instance;
+        return instance;
+    }
 
-    DiagnosticStorageImpl(const DiagnosticStorageImpl &)             = delete;
-    DiagnosticStorageImpl & operator=(const DiagnosticStorageImpl &) = delete;
+    // Delete copy constructor and assignment operator to ensure singleton
+    CircularDiagnosticBuffer(const CircularDiagnosticBuffer &)             = delete;
+    CircularDiagnosticBuffer & operator=(const CircularDiagnosticBuffer &) = delete;
 
-    CHIP_ERROR Store(DiagnosticEntry & diagnostic) override;
+    void Init(uint8_t * buffer, size_t bufferLength) { chip::TLV::TLVCircularBuffer::Init(buffer, bufferLength); }
 
-    CHIP_ERROR Retrieve(MutableByteSpan & payload) override;
+    CHIP_ERROR Store(DiagnosticEntry & entry) override
+    {
+        chip::TLV::CircularTLVWriter writer;
+        writer.Init(*this);
 
-    bool IsEmptyBuffer();
+        CHIP_ERROR err = entry.Encode(writer);
+        if (err != CHIP_NO_ERROR)
+        {
+            ChipLogError(DeviceLayer, "Failed to write entry: %s", chip::ErrorStr(err));
+        }
+        return err;
+    }
 
-    uint32_t GetDataSize();
+    CHIP_ERROR Retrieve(MutableByteSpan & span) override
+    {
+        CHIP_ERROR err = CHIP_NO_ERROR;
+        chip::TLV::TLVReader reader;
+        reader.Init(*this);
 
-private:
-    DiagnosticStorageImpl(uint8_t * buffer, size_t bufferSize);
-    DiagnosticStorageImpl();
-    ~DiagnosticStorageImpl();
+        chip::TLV::TLVWriter writer;
+        writer.Init(span.data(), span.size());
+
+        chip::TLV::TLVType outWriterContainer;
+        err = writer.StartContainer(chip::TLV::AnonymousTag(), chip::TLV::kTLVType_List, outWriterContainer);
+        VerifyOrReturnError(err == CHIP_NO_ERROR, err, ChipLogError(DeviceLayer, "Failed to start container"));
+
+        while (CHIP_NO_ERROR == reader.Next())
+        {
+            VerifyOrReturnError(err == CHIP_NO_ERROR, err,
+                                ChipLogError(DeviceLayer, "Failed to read next TLV element: %s", ErrorStr(err)));
+
+            if (reader.GetType() == chip::TLV::kTLVType_Structure && reader.GetTag() == chip::TLV::AnonymousTag())
+            {
+                chip::TLV::TLVType outerReaderContainer;
+                err = reader.EnterContainer(outerReaderContainer);
+                VerifyOrReturnError(err == CHIP_NO_ERROR, err,
+                                    ChipLogError(DeviceLayer, "Failed to enter outer TLV container: %s", ErrorStr(err)));
+
+                err = reader.Next();
+                VerifyOrReturnError(
+                    err == CHIP_NO_ERROR, err,
+                    ChipLogError(DeviceLayer, "Failed to read next TLV element in outer container: %s", ErrorStr(err)));
 
-    chip::TLV::TLVCircularBuffer mEndUserCircularBuffer;
+                if ((reader.GetType() == chip::TLV::kTLVType_Structure) &&
+                    (reader.GetTag() == chip::TLV::ContextTag(DIAGNOSTICS_TAG::METRIC) ||
+                     reader.GetTag() == chip::TLV::ContextTag(DIAGNOSTICS_TAG::TRACE) ||
+                     reader.GetTag() == chip::TLV::ContextTag(DIAGNOSTICS_TAG::COUNTER)))
+                {
+                    if ((reader.GetLengthRead() - writer.GetLengthWritten()) < ((writer.GetRemainingFreeLength() + TLV_CLOSING_BYTES)))
+                    {
+                        err = writer.CopyElement(reader);
+                        if (err == CHIP_ERROR_BUFFER_TOO_SMALL)
+                        {
+                            ChipLogProgress(DeviceLayer, "Buffer too small to occupy current element");
+                            break;
+                        }
+                        VerifyOrReturnError(err == CHIP_NO_ERROR, err, ChipLogError(DeviceLayer, "Failed to copy TLV element"));
+                    }
+                    else
+                    {
+                        ChipLogProgress(DeviceLayer, "Buffer too small to occupy current TLV");
+                        break;
+                    }
+                }
+                else
+                {
+                    ChipLogError(DeviceLayer, "Unexpected TLV element in outer container");
+                    reader.ExitContainer(outerReaderContainer);
+                    return CHIP_ERROR_WRONG_TLV_TYPE;
+                }
+                err = reader.ExitContainer(outerReaderContainer);
+                VerifyOrReturnError(err == CHIP_NO_ERROR, err,
+                                    ChipLogError(DeviceLayer, "Failed to exit outer TLV container: %s", ErrorStr(err)));
+            }
+            else
+            {
+                ChipLogError(DeviceLayer, "Unexpected TLV element type or tag in outer container");
+            }
+        }
+
+        err = writer.EndContainer(outWriterContainer);
+        VerifyOrReturnError(err == CHIP_NO_ERROR, err, ChipLogError(DeviceLayer, "Failed to close outer container"));
+        err = writer.Finalize();
+        VerifyOrReturnError(err == CHIP_NO_ERROR, err, ChipLogError(DeviceLayer, "Failed to finalize TLV writing"));
+        span.reduce_size(writer.GetLengthWritten());
+        ChipLogProgress(DeviceLayer, "---------------Total written bytes successfully : %ld----------------\n",
+                        writer.GetLengthWritten());
+        ChipLogProgress(DeviceLayer, "Retrieval successful");
+        return CHIP_NO_ERROR;
+    }
+
+    bool IsEmptyBuffer() override { return DataLength() == 0; }
+
+    uint32_t GetDataSize() override { return DataLength(); }
+
+private:
+    CircularDiagnosticBuffer() : chip::TLV::TLVCircularBuffer(nullptr, 0) {}
+    ~CircularDiagnosticBuffer() override = default;
 };
+
 } // namespace Diagnostics
 } // namespace Tracing
 } // namespace chip