admin : added a new admin endpoint - /logs to fetch log files + related bugfix

- Implement `GET /logs?type=<mlog|qlog>&connection_id=<hex>` route.
- Offload blocking file I/O (`std::ifstream::read`) to
  `folly::getGlobalCPUExecutor()` to avoid stalling the admin event loop.
- Bugfix: create log dir if not exists

Author: akash-a-n

CMakeLists.txt

@@ -158,6 +158,7 @@ add_library(moqx_core STATIC
   src/admin/BuiltinRoutes.cpp
   src/admin/CachePurgeHandler.cpp
   src/admin/ConfigHandler.cpp
+  src/admin/ConnectionLogsHandler.cpp
   src/admin/MetricsHandler.cpp
   src/admin/TrackMetricsHandler.cpp
   src/admin/StateHandler.cpp

src/admin/ConnectionLogsHandler.cpp

@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) OpenMOQ contributors.
+ * This source code is licensed under the Apache 2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "admin/ConnectionLogsHandler.h"
+
+#include <cctype>
+#include <string>
+#include <string_view>
+
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#include <folly/CancellationToken.h>
+#include <folly/File.h>
+#include <folly/FileUtil.h>
+#include <folly/coro/Invoke.h>
+#include <folly/coro/Task.h>
+#include <folly/coro/WithCancellation.h>
+#include <folly/executors/GlobalExecutor.h>
+#include <folly/io/IOBuf.h>
+#include <folly/io/async/EventBaseManager.h>
+#include <folly/logging/xlog.h>
+#include <proxygen/httpserver/ResponseBuilder.h>
+#include <proxygen/lib/http/HTTPMessage.h>
+
+#include "admin/AdminResponse.h"
+#include "admin/AdminServer.h"
+
+namespace openmoq::moqx::admin {
+
+namespace {
+
+constexpr size_t kMaxDownloadBytes = 512ULL * 1024 * 1024; // 512 MB hard cap
+
+// Normalize a raw connection ID string:
+//   - strip 0x/0X prefix
+//   - lowercase hex digits
+//   - validate hex-only, 1–40 chars
+std::optional<std::string> normalizeConnectionId(std::string_view raw) {
+  if (raw.size() >= 2 && raw[0] == '0' && (raw[1] == 'x' || raw[1] == 'X')) {
+    raw.remove_prefix(2);
+  }
+  std::string result;
+  result.reserve(raw.size());
+  for (char c : raw) {
+    if (!std::isxdigit(static_cast<unsigned char>(c)))
+      return std::nullopt;
+    result += static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+  }
+  if (result.empty() || result.size() > 40)
+    return std::nullopt;
+  return result;
+}
+
+// Read an entire file into an IOBuf. Returns nullptr if the file cannot be
+// opened, is empty, or exceeds maxBytes.
+std::unique_ptr<folly::IOBuf> readFileToIOBuf(const std::string& path, size_t maxBytes) {
+  folly::File file;
+  try {
+    file = folly::File(path, O_RDONLY);
+  } catch (const std::exception&) {
+    return nullptr;
+  }
+
+  struct stat st{};
+  if (::fstat(file.fd(), &st) != 0 || !S_ISREG(st.st_mode))
+    return nullptr;
+  const auto size = static_cast<size_t>(st.st_size);
+  if (size == 0 || size > maxBytes)
+    return nullptr;
+
+  auto content = std::make_unique<std::string>();
+  if (!folly::readFile(file.fd(), *content, size) || content->size() != size)
+    return nullptr;
+
+  auto* data = content->data();
+  const auto len = content->size();
+  return folly::IOBuf::takeOwnership(
+      data,
+      len,
+      [](void*, void* userData) { delete static_cast<std::string*>(userData); },
+      content.release()
+  );
+}
+
+// Reads the requested log file (on the global CPU pool) and writes the
+// HTTP response. This is a plain, explicitly-typed coroutine function
+// rather than an immediately-invoked generic ("auto"-parameter) lambda:
+// that pattern, combined with a by-value parameter used after a co_await
+// suspension point, is a known trigger for a GCC 11 coroutine codegen bug
+// that manifests as a double-free of the parameter's backing storage under
+// ASAN (observed for both `path` and `name` here). Using a named function
+// with concrete parameter types avoids the pattern entirely.
+folly::coro::Task<void> serveLogFile(
+    std::string path,
+    std::string name,
+    proxygen::ResponseHandler* ds,
+    folly::CancellationToken token
+) {
+  if (token.isCancellationRequested())
+    co_return;
+
+  // Read the file on the global CPU pool to avoid blocking the admin
+  // event-loop thread. Use co_awaitTry (folly::Try) instead of a
+  // try/catch around the co_await to avoid exception unwinding through
+  // the coroutine frame (see MoqxRelay.cpp, UpstreamProvider.cpp for the
+  // same established pattern).
+  auto readResult = co_await folly::coro::co_awaitTry(folly::coro::co_withExecutor(
+      folly::getGlobalCPUExecutor(),
+      folly::coro::co_invoke(
+          [path = std::move(path),
+           maxBytes = kMaxDownloadBytes]() -> folly::coro::Task<std::unique_ptr<folly::IOBuf>> {
+            co_return readFileToIOBuf(path, maxBytes);
+          }
+      )
+  ));
+  if (readResult.hasException()) {
+    XLOG(ERR) << "ConnectionLogsHandler: file read threw: " << readResult.exception().what();
+    if (!token.isCancellationRequested()) {
+      sendError(ds, 500, "internal error\n");
+    }
+    co_return;
+  }
+
+  if (token.isCancellationRequested())
+    co_return;
+
+  std::unique_ptr<folly::IOBuf> fileBuf = std::move(readResult.value());
+  if (!fileBuf) {
+    sendError(ds, 404, "log file not found or exceeds size limit\n");
+    co_return;
+  }
+
+  proxygen::ResponseBuilder(ds)
+      .status(200, proxygen::HTTPMessage::getDefaultReason(200))
+      .header("Content-Type", "application/json")
+      .header("Content-Disposition", "attachment; filename=\"" + name + "\"")
+      .body(std::move(fileBuf))
+      .sendWithEOM();
+}
+
+} // namespace
+
+void registerConnectionLogsRoutes(
+    AdminServer& adminServer,
+    const std::optional<config::LoggingConfig>& logging
+) {
+  std::string mlogDir, qlogDir;
+  if (logging) {
+    if (logging->mlog && !logging->mlog->dir.empty()) {
+      mlogDir = logging->mlog->dir;
+    }
+    if (logging->qlog && !logging->qlog->dir.empty()) {
+      qlogDir = logging->qlog->dir;
+    }
+  }
+
+  // ── GET /logs?connection_id=<hex>&type=mlog|qlog
+  //
+  // Path is constructed directly as {dir}/{normalized_cid}.{ext}
+  adminServer.addRoute(
+      "GET",
+      "/logs",
+      [mlogDir = std::move(mlogDir), qlogDir = std::move(qlogDir)](
+          std::unique_ptr<proxygen::HTTPMessage> req,
+          std::unique_ptr<folly::IOBuf> /*body*/,
+          proxygen::ResponseHandler* downstream,
+          folly::CancellationToken cancelToken
+      ) {
+        // Resolve type → directory, file extension, Content-Type.
+        const auto& typeStr = req->getQueryParam("type");
+        const std::string* dir = nullptr;
+        const char* ext = nullptr;
+        if (typeStr == "mlog") {
+          dir = &mlogDir;
+          ext = ".mlog";
+        } else if (typeStr == "qlog") {
+          dir = &qlogDir;
+          ext = ".qlog";
+        } else {
+          sendError(downstream, 400, "type must be 'mlog' or 'qlog'\n");
+          return;
+        }
+
+        if (dir->empty()) {
+          sendError(downstream, 503, "that log type is not configured\n");
+          return;
+        }
+
+        const auto& rawCid = req->getQueryParam("connection_id");
+        if (rawCid.empty()) {
+          sendError(downstream, 400, "missing connection_id\n");
+          return;
+        }
+
+        auto normCid = normalizeConnectionId(rawCid);
+        if (!normCid) {
+          sendError(downstream, 400, "invalid connection_id\n");
+          return;
+        }
+
+        // {dir}/{normalizedCid}.{ext}
+        auto filePath = *dir + "/" + *normCid + ext;
+        auto fileName = *normCid + ext;
+
+        auto* evb = folly::EventBaseManager::get()->getEventBase();
+        folly::coro::co_withCancellation(
+            cancelToken,
+            folly::coro::co_withExecutor(
+                evb,
+                serveLogFile(std::move(filePath), std::move(fileName), downstream, cancelToken)
+            )
+        )
+            .start();
+      }
+  );
+}
+
+} // namespace openmoq::moqx::admin

src/admin/ConnectionLogsHandler.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) OpenMOQ contributors.
+ * This source code is licensed under the Apache 2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <optional>
+
+#include "config/Config.h"
+
+namespace openmoq::moqx::admin {
+
+class AdminServer;
+
+// Registers GET /logs on the admin server.
+//
+// GET /logs?connection_id=<hex>&type=mlog|qlog
+//   Resolves the file path as {log_dir}/{normalized_cid}.{ext} and streams
+//   the file directly. No index or disk scan is required — files written
+//   after startup are immediately reachable.
+//   Responds 400 for missing/invalid params, 503 if the requested type is
+//   not configured, 404 if the file does not exist.
+void registerConnectionLogsRoutes(
+    AdminServer& adminServer,
+    const std::optional<config::LoggingConfig>& logging
+);
+
+} // namespace openmoq::moqx::admin

src/config/ConfigResolver.cpp

@@ -1240,7 +1240,11 @@ folly::Expected<ResolvedConfig, std::string> resolveConfig(const ParsedConfig& c
       if (!mlogConfig.dir.empty()) {
         std::error_code ec;
         const auto st = std::filesystem::status(mlogConfig.dir, ec);
-        if (ec) {
+        // A missing directory is not an error here: LogSetup creates it
+        // (via create_directories) before logging starts. Only reject
+        // genuine access failures (e.g. permission denied on a parent
+        // directory).
+        if (ec && st.type() != std::filesystem::file_type::not_found) {
           return folly::makeUnexpected(
               "Failed to access mlog directory '" + mlogConfig.dir + "': " + ec.message()
           );

src/main.cpp

@@ -10,6 +10,7 @@
 #include "admin/BuiltinRoutes.h"
 #include "admin/CachePurgeHandler.h"
 #include "admin/ConfigHandler.h"
+#include "admin/ConnectionLogsHandler.h"
 #include "admin/MetricsHandler.h"
 #include "admin/StateHandler.h"
 #include "admin/TrackMetricsHandler.h"
@@ -204,6 +205,7 @@ int main(int argc, char* argv[]) {
   }
   admin::registerTrackMetricsRoute(adminServer, context, trackLimits);
   admin::registerConfigRoute(adminServer, std::make_shared<const cfg::Config>(config));
+  admin::registerConnectionLogsRoutes(adminServer, config.logging);
 
   // === 8. Start serving ===
   for (auto& server : servers) {

test/CMakeLists.txt

@@ -348,6 +348,10 @@ add_test(
   NAME admin_config_endpoint
   COMMAND bash ${PROJECT_SOURCE_DIR}/test/test_admin_config.sh $<TARGET_FILE:moqx>
 )
+add_test(
+  NAME admin_connection_logs_endpoint
+  COMMAND bash ${PROJECT_SOURCE_DIR}/test/test_admin_connection_logs.sh $<TARGET_FILE:moqx>
+)
 add_test(
   NAME admin_cache_purge_concurrency_test
   COMMAND bash ${PROJECT_SOURCE_DIR}/test/test_admin_cache_purge_race.sh $<TARGET_FILE:moqx>