[lldb] Add RotatingLogHandler

[JDevlieghere]

Summary

Add a log handler that maintains a circular buffer.

[kastiglione]

lldb/include/lldb/Utility/Log.h

100

this could be an array, since it's not being dynamically resized.

[JDevlieghere]

• Use dynamic array instead of vector.
• Rebase

[kastiglione]

lgtm

lldb/unittests/Utility/LogTest.cpp

112

minor: return buffer;

[JDevlieghere]

lldb/unittests/Utility/LogTest.cpp

112

I did that on purpose to avoid the call to flush but looking at the raw_string_ostream the stream is unbuffered and str doesn't even call flush under the hood. TIL.

lldb/include/lldb/Utility/Log.h

public:
   static std::shared_ptr<CallbackLogHandler>
   Create(lldb::LogOutputCallback callback, void *baton);
 
 private:
   lldb::LogOutputCallback m_callback;
   void *m_baton;
 };
 
+class RotatingLogHandler : public LogHandler {
+public:
+  RotatingLogHandler(size_t size);
+
+  void Emit(llvm::StringRef message) override;
+  void Dump(llvm::raw_ostream &stream) const;
+
+  static std::shared_ptr<RotatingLogHandler> Create(size_t size);
+
+private:
+  size_t NormalizeIndex(size_t i) const;
+  size_t GetNumMessages() const;
+  size_t GetFirstMessageIndex() const;
+
+  std::unique_ptr<std::string[]> m_messages;
+  const size_t m_size = 0;
+  size_t m_next_index = 0;
+  size_t m_total_count = 0;
+};
+
 class Log final {
 public:
   /// The underlying type of all log channel enums. Declare them as:
   /// enum class MyLog : MaskType {
   ///   Channel0 = Log::ChannelFlag<0>,
   ///   Channel1 = Log::ChannelFlag<1>,
   ///   ...,
   ///   LLVM_MARK_AS_BITMASK_ENUM(LastChannel),

lldb/source/Utility/Log.cpp

 void CallbackLogHandler::Emit(llvm::StringRef message) {
   m_callback(message.data(), m_baton);
 }
 
 std::shared_ptr<CallbackLogHandler>
 CallbackLogHandler::Create(lldb::LogOutputCallback callback, void *baton) {
   return std::make_shared<CallbackLogHandler>(callback, baton);
 }
+
+RotatingLogHandler::RotatingLogHandler(size_t size)
+    : m_messages(std::make_unique<std::string[]>(size)), m_size(size) {}
+
+void RotatingLogHandler::Emit(llvm::StringRef message) {
+  ++m_total_count;
+  const size_t index = m_next_index;
+  m_next_index = NormalizeIndex(index + 1);
+  m_messages[index] = message.str();
+}
+
+size_t RotatingLogHandler::NormalizeIndex(size_t i) const { return i % m_size; }
+
+size_t RotatingLogHandler::GetNumMessages() const {
+  return m_total_count < m_size ? m_total_count : m_size;
+}
+
+size_t RotatingLogHandler::GetFirstMessageIndex() const {
+  return m_total_count < m_size ? 0 : m_next_index;
+}
+
+void RotatingLogHandler::Dump(llvm::raw_ostream &stream) const {
+  const size_t start_idx = GetFirstMessageIndex();
+  const size_t stop_idx = start_idx + GetNumMessages();
+  for (size_t i = start_idx; i < stop_idx; ++i) {
+    const size_t idx = NormalizeIndex(i);
+    stream << m_messages[idx];
+  }
+  stream.flush();
+}
+
+std::shared_ptr<RotatingLogHandler> RotatingLogHandler::Create(size_t size) {
+  return std::make_shared<RotatingLogHandler>(size);
+}

lldb/unittests/Utility/LogTest.cpp

protected:
   std::shared_ptr<LogHandler> getLogHandler() { return m_log_handler_sp; }
   Log *getLog() { return m_log; }
   llvm::StringRef takeOutput();
   llvm::StringRef logAndTakeOutput(llvm::StringRef Message);
 
 public:
   void SetUp() override;
 };
+
+static std::string GetDumpAsString(const RotatingLogHandler &handler) {
+  std::string buffer;
+  llvm::raw_string_ostream stream(buffer);
+  handler.Dump(stream);
+  return stream.str();
+}
 } // end anonymous namespace
 
 void LogChannelEnabledTest::SetUp() {
   LogChannelTest::SetUp();
 
   std::string error;
   ASSERT_TRUE(EnableChannel(m_log_handler_sp, 0, "chan", {}, error));
 

 } // namespace
 
 TEST(LogTest, CallbackLogHandler) {
   CallbackLogHandler handler(TestCallback, &test_baton);
   handler.Emit("Foobar");
   EXPECT_EQ(1u, callback_count);
 }
 
+TEST(LogHandlerTest, RotatingLogHandler) {
+  RotatingLogHandler handler(3);
+
+  handler.Emit("foo");
+  handler.Emit("bar");
+  EXPECT_EQ(GetDumpAsString(handler), "foobar");
+
+  handler.Emit("baz");
+  handler.Emit("qux");
+  EXPECT_EQ(GetDumpAsString(handler), "barbazqux");
+
+  handler.Emit("quux");
+  EXPECT_EQ(GetDumpAsString(handler), "bazquxquux");
+}
+
 TEST_F(LogChannelTest, Enable) {
   EXPECT_EQ(nullptr, GetLog(TestChannel::FOO));
   std::string message;
   auto log_handler_sp = std::make_shared<TestLogHandler>();
   std::string error;
   ASSERT_FALSE(EnableChannel(log_handler_sp, 0, "chanchan", {}, error));
   EXPECT_EQ("Invalid log channel 'chanchan'.\n", error);