Clean up

- Enable tcp_nodelay for all sessions
- Turn off stats collector for all sessions
- Update the session_stats struct to have start and end timepoints rather than duration
- Clean up includes, be more specific for beast

Dockerfile

@@ -10,7 +10,7 @@ RUN apk update && apk add --no-cache \
     g++ \
     liburing-dev \
     linux-headers \
-    make \
+    ninja \
     py-pip
 
 # Install conan package manager
@@ -27,7 +27,7 @@ RUN conan install .. --build=missing
 
 # Configure, build with static musl/libc and libstdc++ so we can run on the
 # scratch empty base image
-RUN cmake -B . -S .. \
+RUN cmake .. -GNinja \
     -DCMAKE_BUILD_TYPE=Release \
     -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake \
     -DENABLE_STANDALONE=ON \

include/httpmicroservice.hpp

@@ -8,6 +8,6 @@ int run(int port, request_handler handler);
 
 int getenv_port();
 
-response make_response(request req);
+response make_response(const request& req);
 
 } // namespace httpmicroservice

include/httpmicroservice/service.hpp

@@ -18,6 +18,8 @@ namespace asio = boost::asio;
 template <typename Acceptor, typename Handler>
 asio::awaitable<void> accept(Acceptor acceptor, Handler handler)
 {
+    using tcp = asio::ip::tcp;
+
     for (;;) {
         boost::system::error_code ec;
 
@@ -28,12 +30,15 @@ asio::awaitable<void> accept(Acceptor acceptor, Handler handler)
             break;
         }
 
+        stream.set_option(tcp::no_delay{true}, ec);
+
+        if (ec) {
+            continue;
+        }
+
         // Run coroutine to handle one http connection
         co_spawn(
-            acceptor.get_executor(),
-            session(
-                std::move(stream), handler,
-                std::make_optional<session_stats>()),
+            acceptor.get_executor(), session(std::move(stream), handler, {}),
             [](auto ptr, auto stats) {
                 // Propagate exception from the coroutine
                 if (ptr) {

include/httpmicroservice/session.hpp

@@ -10,8 +10,9 @@
 #include <boost/asio/awaitable.hpp>
 #include <boost/asio/redirect_error.hpp>
 #include <boost/asio/use_awaitable.hpp>
-#include <boost/beast/core.hpp>
-#include <boost/beast/http.hpp>
+#include <boost/beast/core/flat_buffer.hpp>
+#include <boost/beast/http/read.hpp>
+#include <boost/beast/http/write.hpp>
 
 #include <chrono>
 #include <functional>
@@ -21,28 +22,26 @@ namespace httpmicroservice {
 
 namespace asio = boost::asio;
 
-constexpr auto kRequestSizeLimit = 1 << 20;
+// 1 MB request limit
+constexpr auto kRequestSizeLimit = 1000 * 1000;
 
 template <typename AsyncStream, typename Handler>
 asio::awaitable<std::optional<session_stats>>
 session(AsyncStream stream, Handler handler, std::optional<session_stats> stats)
 {
-    std::chrono::steady_clock::time_point start_time;
     if (stats) {
         stats->fd = stream.native_handle();
-        start_time = std::chrono::steady_clock::now();
+        stats->start_time = std::chrono::steady_clock::now();
     }
 
     boost::beast::flat_buffer buffer(kRequestSizeLimit);
     boost::system::error_code ec;
 
-    // stream.set_option(asio::ip::tcp::no_delay{true}, ec);
-
     for (;;) {
         // req = read(...)
         request req;
         {
-            auto bytes_read = co_await http::async_read(
+            const auto bytes_read = co_await http::async_read(
                 stream, buffer, req,
                 asio::redirect_error(asio::use_awaitable, ec));
 
@@ -60,15 +59,15 @@ session(AsyncStream stream, Handler handler, std::optional<session_stats> stats)
             }
         }
 
-        auto keep_alive = req.keep_alive();
+        const auto keep_alive = req.keep_alive();
 
         // res = handler(req)
         response res = co_await std::invoke(handler, std::move(req));
         res.prepare_payload();
         res.keep_alive(keep_alive);
 
         // write(res)
-        auto bytes_write = co_await http::async_write(
+        const auto bytes_write = co_await http::async_write(
             stream, res, asio::redirect_error(asio::use_awaitable, ec));
 
         if (ec) {
@@ -87,7 +86,7 @@ session(AsyncStream stream, Handler handler, std::optional<session_stats> stats)
     }
 
     if (stats) {
-        stats->duration = std::chrono::steady_clock::now() - start_time;
+        stats->end_time = std::chrono::steady_clock::now();
     }
 
     co_return stats;

include/httpmicroservice/types.hpp

@@ -10,7 +10,7 @@
 #include <fmt/core.h>
 
 #include <chrono>
-#include <string>
+#include <functional>
 
 namespace httpmicroservice {
 
@@ -25,14 +25,16 @@ struct session_stats {
     int num_request{0};
     int bytes_read{0};
     int bytes_write{0};
-    std::chrono::steady_clock::duration duration{};
+    std::chrono::steady_clock::time_point start_time{};
+    std::chrono::steady_clock::time_point end_time{};
 };
 
 } // namespace httpmicroservice
 
 template <>
 struct fmt::formatter<httpmicroservice::session_stats> {
-    constexpr auto parse(format_parse_context& ctx) {
+    constexpr auto parse(format_parse_context& ctx)
+    {
         return ctx.begin();
     }
 
@@ -45,6 +47,7 @@ struct fmt::formatter<httpmicroservice::session_stats> {
             "{{\"fd\": {}, \"num_request\": {}, \"bytes_read\": {}, "
             "\"bytes_write\": {}, \"duration\": {}}}",
             stats.fd, stats.num_request, stats.bytes_read, stats.bytes_write,
-            std::chrono::duration<double>(stats.duration).count());
+            std::chrono::duration<double>(stats.end_time - stats.start_time)
+                .count());
     }
 };

src/httpmicroservice.cpp

@@ -7,9 +7,9 @@
 
 namespace httpmicroservice {
 
-response make_response(request req)
+response make_response(const request& req)
 {
-    return response(http::status::ok, req.version());
+    return response{http::status::ok, req.version()};
 }
 
 int run(int port, request_handler handler)