chore: update gitignore for generated files

.gitignore

@@ -1,4 +1,16 @@
+# Generated documentation
+docs/
+
+# Logs
+*.log
+
+# Cache directories
+.cache/
+
 # ---> C++
+# compilation database
+compile_commands.json
+
 # Prerequisites
 *.d
 

Dockerfile

@@ -0,0 +1,15 @@
+FROM ubuntu:24.04
+
+RUN apt update && apt install -y \
+  build-essential \
+  cmake \
+  gdb \
+  valgrind \
+  git \
+  && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /project
+
+COPY . .
+
+CMD ["bash"]

Makefile

@@ -29,3 +29,6 @@ clean:
 	$(MAKE) -C logger clean
 	$(MAKE) -C app clean
 	$(MAKE) -C tests clean
+
+include docker.mk
+include docs.mk

app/Makefile

@@ -1,4 +1,5 @@
 CXXFLAGS := \
+	-I$(ROOT_DIR)/app/include \
 	-I$(ROOT_DIR)/core/include \
 	-I$(ROOT_DIR)/logger/include
 
@@ -9,7 +10,10 @@ LDLIBS += -llogger
 
 TARGET := $(BUILD_DIR)/logger_app
 
-SRC := src/main.cpp
+SRC := \
+	src/main.cpp \
+	src/message_queue.cpp \
+	src/logger_worker.cpp
 
 .PHONY: all clean
 

app/include/logger_worker.hpp

@@ -0,0 +1,125 @@
+#pragma once
+
+#include <thread>
+
+#include "logger.hpp"
+#include "message_queue.hpp"
+
+namespace app {
+
+/**
+ * @brief Фоновый поток записи сообщений в журнал.
+ *
+ * LoggerWorker получает сообщения из MessageQueue и передаёт их
+ * в библиотеку Logger для записи в файл.
+ *
+ * Logger передаётся в worker по значению и перемещается внутрь объекта.
+ * LoggerWorker становится владельцем логгера.
+ *
+ * Объект Logger используется только внутри рабочего потока,
+ * поэтому потокобезопасность Logger не требуется.
+ */
+class LoggerWorker {
+public:
+  /**
+   * @brief Создаёт worker для записи сообщений.
+   *
+   * Переданный Logger перемещается внутрь объекта LoggerWorker.
+   *
+   * @param logger Логгер, используемый для записи.
+   * @param queue Очередь сообщений.
+   */
+  LoggerWorker(logger::Logger logger, MessageQueue &queue);
+
+  /**
+   * @brief Останавливает поток записи.
+   *
+   * Останавливает очередь сообщений и дожидается завершения
+   * рабочего потока после обработки оставшихся сообщений.
+   */
+  ~LoggerWorker();
+
+  /**
+   * @brief Запрещает копирование worker.
+   */
+  LoggerWorker(const LoggerWorker &) = delete;
+
+  /**
+   * @brief Запрещает копирующее присваивание.
+   */
+  LoggerWorker &operator=(const LoggerWorker &) = delete;
+
+  /**
+   * @brief Разрешает перемещение worker.
+   *
+   * Передаёт владение потоком записи и состоянием объекта.
+   */
+  LoggerWorker(LoggerWorker &&) noexcept = default;
+
+  /**
+   * @brief Разрешает перемещающее присваивание worker.
+   */
+  LoggerWorker &operator=(LoggerWorker &&) noexcept = default;
+
+  /**
+   * @brief Запускает поток записи сообщений.
+   */
+  void start();
+
+  /**
+   * @brief Возвращает используемый логгер.
+   *
+   * Позволяет получить текущую конфигурацию логгера,
+   * например имя файла журнала или уровень логирования
+   * по умолчанию.
+   *
+   * @return Константная ссылка на логгер.
+   */
+  [[nodiscard]]
+  const logger::Logger &getLogger() const;
+
+  /**
+   * @brief Устанавливает новый логгер.
+   *
+   * Новый Logger заменяет текущий.
+   * Переданный объект перемещается внутрь worker.
+   *
+   * @param logger Новый логгер.
+   */
+  void setLogger(logger::Logger logger);
+
+  /**
+   * @brief Останавливает обработку сообщений.
+   *
+   * После остановки очереди новые сообщения не принимаются.
+   * Рабочий поток завершится после обработки всех сообщений,
+   * которые уже находились в очереди.
+   */
+  void stop();
+
+private:
+  /**
+   * @brief Основной цикл рабочего потока.
+   */
+  void process();
+
+private:
+  /**
+   * @brief Логгер для записи сообщений.
+   *
+   * Используется только рабочим потоком.
+   */
+  logger::Logger logger_;
+
+  /**
+   * @brief Очередь входящих сообщений.
+   */
+  MessageQueue &queue_;
+
+  /**
+   * @brief Поток записи.
+   */
+  std::thread workerThread_;
+};
+
+} // namespace app

app/include/message_queue.hpp

@@ -2,6 +2,7 @@
 
 #include <condition_variable>
 #include <mutex>
+#include <optional>
 #include <queue>
 
 #include "log_message.hpp"
@@ -22,6 +23,8 @@ public:
    *
    * Метод является потокобезопасным.
    *
+   * После остановки очереди новые сообщения не принимаются.
+   *
    * @param message Сообщение для передачи.
    */
   void push(LogMessage message);
@@ -29,15 +32,28 @@ public:
   /**
    * @brief Извлекает сообщение из очереди.
    *
-   * Если очередь пуста, метод блокирует вызывающий
+   * Если очередь пуста, метод блокирует вызывающий поток
-   * поток до появления нового сообщения.
+   * до появления нового сообщения или до остановки очереди.
+   *
+   * После остановки очереди и обработки всех оставшихся сообщений
+   * возвращается std::nullopt.
    *
    * Метод является потокобезопасным.
    *
-   * @return Следующее сообщение из очереди.
+   * @return Следующее сообщение или std::nullopt, если очередь остановлена.
    */
   [[nodiscard]]
-  LogMessage pop();
+  std::optional<LogMessage> pop();
+
+  /**
+   * @brief Останавливает очередь.
+   *
+   * Пробуждает все ожидающие потоки. После вызова stop()
+   * новые сообщения не принимаются.
+   *
+   * Метод является потокобезопасным.
+   */
+  void stop();
 
   /**
    * @brief Проверяет, пуста ли очередь.
@@ -56,6 +72,11 @@ private:
    */
   std::queue<LogMessage> queue_;
 
+  /**
+   * @brief Признак остановки очереди.
+   */
+  bool stopped_{false};
+
   /**
    * @brief Мьютекс для синхронизации доступа к очереди.
    */

app/src/logger_worker.cpp

@@ -0,0 +1,41 @@
+#include "logger_worker.hpp"
+
+#include <iostream>
+#include <utility>
+
+namespace app {
+
+LoggerWorker::LoggerWorker(logger::Logger logger, MessageQueue &queue)
+    : logger_(std::move(logger)), queue_(queue) {}
+
+LoggerWorker::~LoggerWorker() { stop(); }
+
+void LoggerWorker::start() {
+  workerThread_ = std::thread(&LoggerWorker::process, this);
+}
+
+void LoggerWorker::stop() {
+  queue_.stop();
+
+  if (workerThread_.joinable()) {
+    workerThread_.join();
+  }
+}
+
+const logger::Logger &LoggerWorker::getLogger() const { return logger_; }
+
+void LoggerWorker::setLogger(logger::Logger logger) {
+  logger_ = std::move(logger);
+}
+
+void LoggerWorker::process() {
+  while (auto message = queue_.pop()) {
+    auto status = logger_.writeMessage(message->level, message->message);
+
+    if (!status.isSuccess()) {
+      std::cerr << "Logger error: " << status.getError() << '\n';
+    }
+  }
+}
+
+} // namespace app

app/src/main.cpp

@@ -1,17 +1,216 @@
 #include <iostream>
+#include <string>
 
 #include "logger.hpp"
+#include "logger_worker.hpp"
+#include "message_queue.hpp"
+
+namespace {
+
+void printMainMenu() {
+  std::cout << "\n*** Logger ***\n"
+            << "  1: [w]rite message\n"
+            << "  2: [c]onfigure\n"
+            << "  3: [q]uit\n"
+            << "What now> ";
+}
+
+void printConfigureMenu() {
+  std::cout << "\n*** Configure ***\n"
+            << "  1: change [d]efault level\n"
+            << "  2: change [c]urrent level\n"
+            << "  3: [b]ack\n"
+            << "What now> ";
+}
+
+void printWriteMenu() {
+  std::cout << "\n*** Write Message ***\n"
+            << "  1: use [d]efault level\n"
+            << "  2: use [c]urrent level\n"
+            << "  3: [b]ack\n"
+            << "What now> ";
+}
+
+void printLogLevelMenu(const std::string &title,
+                       logger::LogLevel currentLevel) {
+  std::cout << "\n*** " << title << " ***\n"
+            << "\nCurrent: " << currentLevel.toString() << "\n\n"
+            << "  1: [d]ebug\n"
+            << "  2: [i]nfo\n"
+            << "  3: [e]rror\n"
+            << "  4: [b]ack\n"
+            << "Select level> ";
+}
+
+char readCommand() {
+  std::string command;
+  std::getline(std::cin, command);
+
+  return command.empty() ? '\0' : command.front();
+}
+
+} // namespace
 
 int main() {
   logger::Logger logger("app.log", logger::LogLevel::info());
 
-  auto status = logger.writeMessage("Hello from shared library");
+  app::MessageQueue queue;
+  app::LoggerWorker worker(std::move(logger), queue);
 
-  if (!status.isSuccess()) {
+  worker.start();
-    std::cerr << status.getError() << '\n';
 
-    return 1;
+  logger::LogLevel currentLevel = logger::LogLevel::info();
+
+  bool running = true;
+
+  while (running) {
+    printMainMenu();
+
+    switch (readCommand()) {
+    case 'w': {
+      bool writing = true;
+
+      while (writing) {
+        printWriteMenu();
+
+        std::optional<logger::LogLevel> level;
+
+        switch (readCommand()) {
+        case 'd':
+          level = worker.getLogger().getLogLevel();
+          break;
+
+        case 'c':
+          level = currentLevel;
+          break;
+
+        case 'b':
+          writing = false;
+          continue;
+
+        default:
+          std::cout << "Unknown command.\n";
+          continue;
         }
 
+        std::cout << "Message> ";
+
+        std::string message;
+        std::getline(std::cin, message);
+
+        queue.push({*level, message});
+
+        writing = false;
+      }
+
+      break;
+    }
+
+    case 'c': {
+      bool configuring = true;
+
+      while (configuring) {
+        printConfigureMenu();
+
+        switch (readCommand()) {
+        case 'd': {
+          bool selecting = true;
+
+          while (selecting) {
+            printLogLevelMenu("Default Log Level",
+                              worker.getLogger().getLogLevel());
+
+            switch (readCommand()) {
+            case 'd':
+              worker.setLogger(
+                  worker.getLogger().withLogLevel(logger::LogLevel::debug()));
+              selecting = false;
+              break;
+
+            case 'i':
+              worker.setLogger(
+                  worker.getLogger().withLogLevel(logger::LogLevel::info()));
+              selecting = false;
+              break;
+
+            case 'e':
+              worker.setLogger(
+                  worker.getLogger().withLogLevel(logger::LogLevel::error()));
+              selecting = false;
+              break;
+
+            case 'b':
+              selecting = false;
+              break;
+
+            default:
+              std::cout << "Unknown command.\n";
+              break;
+            }
+          }
+
+          break;
+        }
+
+        case 'c': {
+          bool selecting = true;
+
+          while (selecting) {
+            printLogLevelMenu("Current Log Level", currentLevel);
+
+            switch (readCommand()) {
+            case 'd':
+              currentLevel = logger::LogLevel::debug();
+              selecting = false;
+              break;
+
+            case 'i':
+              currentLevel = logger::LogLevel::info();
+              selecting = false;
+              break;
+
+            case 'e':
+              currentLevel = logger::LogLevel::error();
+              selecting = false;
+              break;
+
+            case 'b':
+              selecting = false;
+              break;
+
+            default:
+              std::cout << "Unknown command.\n";
+              break;
+            }
+          }
+
+          break;
+        }
+
+        case 'b':
+          configuring = false;
+          break;
+
+        default:
+          std::cout << "Unknown command.\n";
+          break;
+        }
+      }
+
+      break;
+    }
+
+    case 'q':
+      running = false;
+      break;
+
+    default:
+      std::cout << "Unknown command.\n";
+      break;
+    }
+  }
+
+  worker.stop();
+
   return 0;
 }

app/src/message_queue.cpp

@@ -5,15 +5,24 @@ namespace app {
 void MessageQueue::push(LogMessage message) {
   std::lock_guard<std::mutex> lock(mutex_);
 
+  if (stopped_) {
+    return;
+  }
+
   queue_.push(std::move(message));
 
   conditionVariable_.notify_one();
 }
 
-LogMessage MessageQueue::pop() {
+std::optional<LogMessage> MessageQueue::pop() {
   std::unique_lock<std::mutex> lock(mutex_);
 
-  conditionVariable_.wait(lock, [this]() { return !queue_.empty(); });
+  conditionVariable_.wait(lock,
+                          [this]() { return stopped_ || !queue_.empty(); });
+
+  if (queue_.empty()) {
+    return std::nullopt;
+  }
 
   auto message = std::move(queue_.front());
 
@@ -22,6 +31,16 @@ LogMessage MessageQueue::pop() {
   return message;
 }
 
+void MessageQueue::stop() {
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    stopped_ = true;
+  }
+
+  conditionVariable_.notify_all();
+}
+
 bool MessageQueue::empty() const {
   std::lock_guard<std::mutex> lock(mutex_);
 

docker.mk

@@ -0,0 +1,36 @@
+DOCKER_IMAGE := threaded-logger-test
+
+.PHONY: docker-build docker-run docker-shell docker-test docker-clean
+
+docker-build:
+	docker build \
+		-t $(DOCKER_IMAGE) \
+		.
+
+docker-run:
+	docker run \
+		--rm \
+		-it \
+		-v $(ROOT_DIR):/project \
+		-w /project \
+		$(DOCKER_IMAGE)
+
+docker-shell:
+	docker run \
+		--rm \
+		-it \
+		-v $(ROOT_DIR):/project \
+		-w /project \
+		$(DOCKER_IMAGE) \
+		bash
+
+docker-test:
+	docker run \
+		--rm \
+		-v $(ROOT_DIR):/project \
+		-w /project \
+		$(DOCKER_IMAGE) \
+		make clean all
+
+docker-clean:
+	docker rmi $(DOCKER_IMAGE)

docs.mk

@@ -0,0 +1,9 @@
+DOXYGEN_CONFIG := Doxyfile
+
+.PHONY: docs docs-clean
+
+docs:
+	doxygen $(DOXYGEN_CONFIG)
+
+docs-clean:
+	rm -rf docs

logger/include/log_level.hpp

@@ -63,8 +63,20 @@ public:
     return !(*this == other);
   }
 
+  /**
+   * @brief Проверяет, является ли текущий уровень менее важным.
+   *
+   * Используется для фильтрации сообщений:
+   * сообщения с уровнем ниже заданного уровня Logger
+   * не должны записываться в журнал.
+   */
+  [[nodiscard]]
+  bool operator<(const LogLevel &other) const {
+    return static_cast<int>(type_) < static_cast<int>(other.type_);
+  }
+
 private:
-  enum class Type { Debug, Info, Error };
+  enum class Type { Debug = 0, Info = 1, Error = 2 };
 
   explicit LogLevel(Type type) : type_(type) {}
 

logger/include/logger.hpp

@@ -49,14 +49,18 @@ public:
   Logger &operator=(const Logger &) = delete;
 
   /**
-   * @brief Запрещает перемещение Logger.
+   * @brief Разрешает перемещение Logger.
+   *
+   * Передаёт владение ресурсами новому объекту.
    */
-  Logger(Logger &&) = delete;
+  Logger(Logger &&) noexcept = default;
 
   /**
-   * @brief Запрещает перемещающее присваивание.
+   * @brief Разрешает перемещающее присваивание.
+   *
+   * Передаёт владение ресурсами новому объекту.
    */
-  Logger &operator=(Logger &&) = delete;
+  Logger &operator=(Logger &&) noexcept = default;
 
   /**
    * @brief Записывает сообщение в журнал с указанным уровнем логирования.
@@ -140,7 +144,12 @@ private:
   std::string fileName_;
 
   /**
-   * @brief Уровень логирования по умолчанию.
+   * @brief Создаёт объект логгера.
+   *
+   * @param fileName Имя файла, в который будут записываться сообщения.
+   * @param defaultLevel Уровень логирования по умолчанию и минимальный уровень
+   *                     важности сообщений, которые будут записываться в
+   * журнал.
    */
   LogLevel defaultLevel_;
 };

logger/src/logger.cpp

@@ -12,6 +12,10 @@ Logger::Logger(const std::string &fileName, LogLevel defaultLevel)
 Logger::~Logger() = default;
 
 core::Status Logger::writeMessage(LogLevel level, const std::string &message) {
+  if (level < defaultLevel_) {
+    return core::Status::Success(true);
+  }
+
   // std::ios::app — режим добавления в конец файла
   // без удаления уже существующих записей.
   std::ofstream stream(fileName_, std::ios::app);

tests/app/message_queue_test.cpp

@@ -17,8 +17,9 @@ void testPushAndPop() {
 
   auto message = queue.pop();
 
-  assert(message.level == logger::LogLevel::info());
+  assert(message.has_value());
-  assert(message.message == "Hello");
+  assert(message->level == logger::LogLevel::info());
+  assert(message->message == "Hello");
 }
 
 void testFifoOrder() {
@@ -28,9 +29,9 @@ void testFifoOrder() {
   queue.push({logger::LogLevel::info(), "second"});
   queue.push({logger::LogLevel::error(), "third"});
 
-  assert(queue.pop().message == "first");
+  assert(queue.pop()->message == "first");
-  assert(queue.pop().message == "second");
+  assert(queue.pop()->message == "second");
-  assert(queue.pop().message == "third");
+  assert(queue.pop()->message == "third");
 }
 
 void testPopWaitsForMessage() {
@@ -41,8 +42,9 @@ void testPopWaitsForMessage() {
   std::thread worker([&]() {
     auto message = queue.pop();
 
-    assert(message.level == logger::LogLevel::error());
+    assert(message.has_value());
-    assert(message.message == "Delayed");
+    assert(message->level == logger::LogLevel::error());
+    assert(message->message == "Delayed");
 
     received = true;
   });
@@ -74,12 +76,14 @@ void testConcurrentPushAndPop() {
     producers.emplace_back(
         helpers::createProducer(queue, i, messagesPerThread));
   }
+
   const auto expectedMessages = threadCount * messagesPerThread;
 
   for (std::size_t i = 0; i < expectedMessages; ++i) {
     auto message = queue.pop();
 
-    assert(!message.message.empty());
+    assert(message.has_value());
+    assert(!message->message.empty());
   }
 
   for (auto &producer : producers) {
@@ -89,11 +93,44 @@ void testConcurrentPushAndPop() {
   assert(queue.empty());
 }
 
+void testStopReturnsNullopt() {
+  MessageQueue queue;
+
+  queue.stop();
+
+  auto message = queue.pop();
+
+  assert(!message.has_value());
+}
+
+void testStopReturnsRemainingMessages() {
+  MessageQueue queue;
+
+  queue.push({logger::LogLevel::info(), "first"});
+  queue.push({logger::LogLevel::error(), "second"});
+
+  queue.stop();
+
+  auto first = queue.pop();
+  auto second = queue.pop();
+  auto third = queue.pop();
+
+  assert(first.has_value());
+  assert(first->message == "first");
+
+  assert(second.has_value());
+  assert(second->message == "second");
+
+  assert(!third.has_value());
+}
+
 void runTests() {
   testPushAndPop();
   testFifoOrder();
   testPopWaitsForMessage();
   testConcurrentPushAndPop();
+  testStopReturnsNullopt();
+  testStopReturnsRemainingMessages();
 }
 
 } // namespace app::tests

tests/logger/logger_test.cpp

@@ -109,6 +109,64 @@ void testMultipleWrites() {
   assert(secondLine.find("second message") != std::string::npos);
 }
 
+void testIgnoreLowerLogLevel() {
+  helpers::ScopedFile file("filter.log");
+
+  file.throwIfExists();
+
+  Logger logger(file.getFileName(), LogLevel::info());
+
+  // INFO соответствует минимальному уровню логирования,
+  // поэтому сообщение должно быть записано в журнал
+  auto infoResult = logger.writeMessage(LogLevel::info(), "info message");
+
+  assert(infoResult.isSuccess());
+
+  // DEBUG имеет более низкий приоритет, чем установленный уровень INFO.
+  // Сообщение не должно попасть в журнал
+  auto debugResult = logger.writeMessage(LogLevel::debug(), "debug message");
+
+  assert(debugResult.isSuccess());
+
+  std::ifstream input(file.getFileName());
+
+  assert(input.is_open());
+
+  std::string firstLine;
+  std::string secondLine;
+
+  std::getline(input, firstLine);
+
+  assert(firstLine.find("info message") != std::string::npos);
+
+  // Проверяем, что после INFO-сообщения отсутствует DEBUG-сообщение.
+  bool hasSecondLine = static_cast<bool>(std::getline(input, secondLine));
+
+  assert(!hasSecondLine);
+}
+
+void testWriteMessageWithDefaultLevel() {
+  helpers::ScopedFile file("default_level.log");
+
+  file.throwIfExists();
+
+  Logger logger(file.getFileName(), LogLevel::error());
+
+  auto result = logger.writeMessage("critical message");
+
+  assert(result.isSuccess());
+
+  std::ifstream input(file.getFileName());
+
+  assert(input.is_open());
+
+  std::string content;
+
+  std::getline(input, content);
+
+  assert(content.find("critical message") != std::string::npos);
+}
+
 void runTests() {
   testLoggerCreation();
   testWithLogLevel();
@@ -116,6 +174,8 @@ void runTests() {
   testWriteLogSuccess();
   testWriteLogFailure();
   testMultipleWrites();
+  testIgnoreLowerLogLevel();
+  testWriteMessageWithDefaultLevel();
 }
 
 } // namespace logger::tests