feat: AccessLogConfig flush threshold parameter

Author: sjanel

aeronet/objects/include/aeronet/access-log-config.hpp

@@ -21,6 +21,8 @@ struct AccessLogConfig {
     JSON,  // JSON format (requires AERONET_ENABLE_GLAZE at build time)
   };
 
+  bool operator==(const AccessLogConfig&) const = default;
+
   // Output sink. Default: None (disabled).
   Sink sink{Sink::None};
 
@@ -31,6 +33,9 @@ struct AccessLogConfig {
   // Use this when the server is behind a trusted reverse proxy.
   bool useForwardedFor{false};
 
+  // Data will be flushed to sink once the internal buffer of the writer exceeds this size.
+  uint32_t flushThresholdInBytes{8192U};
+
   // File path for the access log when sink == File. Ignored otherwise.
   std::string filePath;
 };

aeronet/objects/test/reserved-headers_test.cpp

@@ -10,9 +10,9 @@ namespace aeronet::http {
 
 TEST(ReservedHeadersTest, ReservedResponseHeaderBasic) {
   EXPECT_TRUE(IsReservedResponseHeader(http::ContentLength));
-  EXPECT_TRUE(IsReservedResponseHeader("date"));
+  EXPECT_TRUE(IsReservedResponseHeader(http::Date));
   EXPECT_TRUE(IsReservedResponseHeader(http::Connection));
-  EXPECT_TRUE(IsReservedResponseHeader("transfer-encoding"));
+  EXPECT_TRUE(IsReservedResponseHeader(http::TransferEncoding));
   EXPECT_TRUE(IsReservedResponseHeader("te"));
   EXPECT_TRUE(IsReservedResponseHeader("trailer"));
   EXPECT_TRUE(IsReservedResponseHeader("upgrade"));

aeronet/server/include/aeronet/access-log-writer.hpp

@@ -39,7 +39,8 @@ class AccessLogWriter {
 
   RawChars32 _buffer;
   BaseFd _fileFd;  // Valid if sink == File, ignored otherwise
-  AccessLogConfig::Format _format = AccessLogConfig::Format::CLF;
+  uint32_t _flushThresholdInBytes{};
+  AccessLogConfig::Format _format{};
   AccessLogConfig::Sink _sink = AccessLogConfig::Sink::None;
 };
 

aeronet/server/src/access-log-writer.cpp

@@ -34,7 +34,8 @@
 
 namespace aeronet {
 
-AccessLogWriter::AccessLogWriter(const AccessLogConfig& config) : _format(config.format), _sink(config.sink) {
+AccessLogWriter::AccessLogWriter(const AccessLogConfig& config)
+    : _flushThresholdInBytes(config.flushThresholdInBytes), _format(config.format), _sink(config.sink) {
   if (_sink == AccessLogConfig::Sink::None) {
     return;
   }
@@ -69,9 +70,7 @@ void AccessLogWriter::log(const RequestMetrics& metrics) {
     formatJSON(metrics);
   }
 
-  static constexpr decltype(_buffer)::size_type kFlushThreshold = 8192;
-
-  if (_buffer.size() >= kFlushThreshold) {
+  if (_buffer.size() >= _flushThresholdInBytes) {
     flush();
   }
 }

aeronet/server/src/http-response-dispatch.cpp

@@ -164,7 +164,6 @@ void SingleHttpServer::finalizeAndSendResponseForHttp1(ConnectionIt cnxIt, HttpR
   queueData(cnxIt, resp.finalizeForHttp1(_dateHeader.data(), request.version(), opts, &_config.globalHeaders,
                                          _config.minCapturedBodySize));
 
-  state.inBuffer.erase_front(consumedBytes);
   if (!keepAlive) {
     // Always request drain+close for non-keep-alive connections. The actual close
     // only triggers once outBuffer is empty (checked by canCloseConnectionForDrain),
@@ -175,6 +174,8 @@ void SingleHttpServer::finalizeAndSendResponseForHttp1(ConnectionIt cnxIt, HttpR
     emitRequestMetrics(request, respStatusCode, request.body().size(), state.requestsServed > 0);
   }
 
+  state.inBuffer.erase_front(consumedBytes);
+
   // End the span after response is finalized
   request.end(respStatusCode);
 }

aeronet/server/src/single-http-server.cpp

@@ -18,6 +18,7 @@
 #include <utility>
 
 #include "aeronet/accept-encoding-negotiation.hpp"
+#include "aeronet/access-log-config.hpp"
 #include "aeronet/connection-state.hpp"
 #include "aeronet/cors-policy.hpp"
 #include "aeronet/event-loop.hpp"
@@ -871,7 +872,8 @@ bool SingleHttpServer::dispatchAsyncHandler(ConnectionIt cnxIt, const AsyncReque
 
   refreshKeepAliveDeadline(cnxIt);
   resumeAsyncHandler(cnxIt);
-  return asyncState.active;
+
+  return true;
 }
 
 void SingleHttpServer::resumeAsyncHandler(ConnectionIt cnxIt) {
@@ -1546,6 +1548,8 @@ void SingleHttpServer::applyPendingUpdates() {
     const TLSConfig tlsBefore = _config.tls;
 #endif
 
+    AccessLogConfig accessLogConfigBefore = _config.accessLog;
+
     ApplyPendingUpdates(_updates.lock, _updates.config, _updates.hasConfig, _config, "config");
 
     // Reinitialize components dependent on config values.
@@ -1567,6 +1571,9 @@ void SingleHttpServer::applyPendingUpdates() {
       }
     }
 #endif
+    if (_config.accessLog != accessLogConfigBefore) {
+      _accessLog = AccessLogWriter(_config.accessLog);
+    }
   }
   if (_updates.hasRouter.load(std::memory_order_acquire)) {
     ApplyPendingUpdates(_updates.lock, _updates.router, _updates.hasRouter, _router, "router");

docs/CHANGELOG.md

@@ -42,6 +42,7 @@ All notable changes to aeronet are documented in this file.
 - **Slightly improved websocket upgrade handler**: minimized allocations and removed a copy.
 - **Improved rate limiter performance** by using a sharding on several locks instead of a unique one.
 - `Http2Config::maxPriorityTreeDepth` is now enforced - stream priority dependencies exceeding the configured depth (or forming a cycle) are clamped to the root instead of being applied.
+- `AccessLogConfig` now has a new parameter `flushThresholdInBytes`, with default value `8192` (was previously hardcoded to this value).
 
 ## Others
 

tests/http-core_test.cpp

@@ -15,6 +15,8 @@
 #include <cstdint>
 #include <cstring>
 #include <filesystem>
+#include <fstream>
+#include <iterator>
 #include <memory>
 #include <ranges>
 #include <regex>
@@ -313,12 +315,40 @@ TEST(HttpBasic, SimpleGet) {
     return resp;
   });
   std::string resp = httpGet("/abc");
-  ASSERT_FALSE(resp.empty());
   ASSERT_TRUE(resp.starts_with("HTTP/1.1 200"));
   ASSERT_TRUE(resp.contains("You requested: /abc"));
   ASSERT_TRUE(resp.contains("x-test=abc123"));
 }
 
+TEST(HttpBasic, AccessLogWriterFile) {
+  ts.router().setDefault([](const HttpRequestView& req) { return req.makeResponse("OK"); });
+
+  test::ScopedTempDir tmpDir;
+
+  std::string logFilePath = tmpDir.dirPath().string() + "/log.txt";
+
+  ts.postConfigUpdate([&logFilePath](HttpServerConfig& cfg) {
+    cfg.accessLog.sink = AccessLogConfig::Sink::File;
+    cfg.accessLog.filePath = logFilePath;
+    cfg.accessLog.flushThresholdInBytes = 0;
+  });
+
+  std::string resp = httpGet("/my-path");
+  ASSERT_TRUE(resp.starts_with("HTTP/1.1 200"));
+
+  resp = httpGet("/other/path");
+  ASSERT_TRUE(resp.starts_with("HTTP/1.1 200"));
+
+  // load contents of logFilePath
+  std::ifstream ifs(logFilePath);
+  std::string logFileContent((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()));
+
+  ts.postConfigUpdate([](HttpServerConfig& cfg) { cfg.accessLog.sink = AccessLogConfig::Sink::None; });
+
+  EXPECT_TRUE(logFileContent.contains(R"(GET /my-path HTTP/1.1" 200 0 )"));
+  EXPECT_TRUE(logFileContent.contains(R"(GET /other/path HTTP/1.1" 200 0 )"));
+}
+
 TEST(HttpKeepAlive, MultipleSequentialRequests) {
   ts.router().setDefault([](const HttpRequestView& req) {
     HttpResponse resp;