feat: portable top-level error-handling

Author: milsanore

README.md

@@ -125,22 +125,22 @@ NB: this app uses `make` as a recipe book, but it's not essential:
   - Valgrind
 - pipeline
   - ✅ custom docker build image with all dependencies (hosted on GHCR for faster pipelines)
-  - ✅ reusable pipeline components + Release pipeline
-  - https://github.com/googleapis/release-please 
+  - ✅ reusable pipeline components
+  - ✅ release pipeline
   - ✅ cron
     - ✅ comprehensive clang-tidy & clang-format checks
     - ✅ sonarcloud
   - ✅ cached dependencies
+  - https://github.com/googleapis/release-please 
   - containerised pipeline integration tests / dind
-  - https://github.com/googleapis/release-please
   - local github action runner (`act`)
   - ccache or precomiled headers
 - testing
   - ✅ coverage gutters
   - ✅ dependency injection
   - integration test with mocked Binance server
   - FTXUI snapshot testing
-- performance
+- performance / latency
   - ✅ store prices and sizes as integrals (ticks as `uint64_t`) for performance
   - ✅ cache line alignment
   - ✅ tcmalloc (Full) / gperftools
@@ -149,7 +149,9 @@ NB: this app uses `make` as a recipe book, but it's not essential:
   - profiling (valgrind/cachegrind)
   - profile-guided optimization (pgo)
   - load test with mocked FIX server
-- latency
+  - set process priority
+  - NIC affinity
+  - QoS
   - sparse arrays & flat matrix
   - memory-mapped files
   - (analyse) find Binance's server location for a low-latency connection
@@ -159,18 +161,18 @@ NB: this app uses `make` as a recipe book, but it's not essential:
   - kernel space vs user space
   - RT OS
 - ✅ logging
-    - ✅ fast
-    - compiled out 'debug' logging for release builds
-    - thread name in logs
-    - rolling
-    - structured
-    - basic schema (severity, correlationId)
-- release process
-  - versioning
-    - master branch merge check for conventional commit message (e.g. regex)
-    - maybe a merge git gook check
-    - automated semantic versioning
-    - github-changelog-generator
+  - ✅ fast
+  - error handling
+  - compiled out 'debug' logging for release builds
+  - thread name in logs
+  - rolling
+  - structured
+  - basic schema (severity, correlationId)
+- versioning
+  - master branch merge check for conventional commit message (e.g. regex)
+  - maybe a merge git gook check
+  - automated semantic versioning
+  - github-changelog-generator
 - observability
   - opentelemetry (asynchronous)
   - grafana+tempo via docker-compose

src/README.md

@@ -9,6 +9,7 @@
     1. order updates (prices/volumes)
     2. trade updates
 - NB: Binance uses a custom authentication mechanism
+- NB: the `Config` class is important
 
 ## core
 - core trading engine functionality

src/main.cpp

@@ -1,3 +1,8 @@
+#include <csignal>
+#include <cstdlib>
+#include <exception>
+#include <iostream>
+#include <new>
 #include <string>
 
 #include "binance/config.h"
@@ -6,36 +11,47 @@
 #include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/spdlog.h"
 #include "ui/app/ui_app.h"
+#include "utils/crash.h"
 #include "utils/env.h"
 #include "utils/threading.h"
 
 int main() {
-  utils::Threading::set_thread_name("main");
+  try {
+    utils::Threading::set_thread_name("main");
 
-  // log config
-  spdlog::cfg::load_env_levels("LOG_LEVEL");
-  const char* log_path = std::getenv("LOG_PATH");
-  const auto logger = spdlog::basic_logger_mt("basic_logger", log_path);
-  spdlog::set_default_logger(logger);
-  // Set a global pattern without the logger name
-  spdlog::set_pattern("[%Y-%m-%d %H:%M:%S.%e] [%^%l%$] [%t] %v");
-  spdlog::flush_every(std::chrono::microseconds(100));
-  spdlog::info("hello");
-  utils::Env::log_current_architecture();
+    // log config
+    spdlog::cfg::load_env_levels("LOG_LEVEL");
+    const char* log_path = std::getenv("LOG_PATH");
+    const auto logger = spdlog::basic_logger_mt("basic_logger", log_path);
+    spdlog::set_default_logger(logger);
+    // Set a global pattern without the logger name
+    spdlog::set_pattern("[%Y-%m-%d %H:%M:%S.%e] [%^%l%$] [%t] %v");
+    spdlog::flush_every(std::chrono::microseconds(100));
+    spdlog::info("hello");
+    utils::Env::log_current_architecture();
 
-  // Binance market data connectivity
-  auto b_conf = binance::Config::from_env();
-  auto b_worker = binance::Worker::from_conf(b_conf);
-  b_worker.start();
+    // configure error-handling
+    utils::Crash::setup_crash_handlers();
 
-  // ui app (reads from Binance's queues)
-  auto ui =
-      ui::App::from_env(b_worker.get_order_queue(), b_worker.get_trade_queue(), b_conf);
-  ui.start();
+    // Binance market data connectivity
+    auto b_conf = binance::Config::from_env();
+    auto b_worker = binance::Worker::from_conf(b_conf);
+    b_worker.start();
 
-  if (ui.thread_exception) {
-    std::rethrow_exception(ui.thread_exception);
+    // ui app (reads from Binance's queues)
+    auto ui =
+        ui::App::from_env(b_worker.get_order_queue(), b_worker.get_trade_queue(), b_conf);
+    // blocking
+    ui.start();
+
+    if (ui.thread_exception) {
+      std::rethrow_exception(ui.thread_exception);
+    }
+    b_worker.stop();
+    spdlog::info("goodbye");
+  } catch (const std::exception& e) {
+    spdlog::error("[EXCEPTION] Caught exception. ex [{}]", e.what());
+  } catch (...) {
+    spdlog::error("[EXCEPTION] Caught unknown exception");
   }
-  b_worker.stop();
-  spdlog::info("goodbye");
 }

src/utils/crash.h

@@ -0,0 +1,95 @@
+#pragma once
+
+#include <csignal>
+#include <cstdlib>
+#include <exception>
+#include <new>
+
+#include "spdlog/spdlog.h"
+
+#ifdef _WIN32
+#include <io.h>
+#define write _write
+#else
+#include <unistd.h>
+#endif
+
+namespace utils {
+
+/// @brief Portable crash handling utility
+class Crash {
+ public:
+  /// @brief std::terminate handler
+  static void handle_terminate() {
+    spdlog::error("[CRITICAL] Unhandled exception or terminate called!");
+    std::abort();  // ensure process exits
+  }
+
+  /// @brief std::new_handler for OOM
+  static void handle_bad_alloc() {
+    spdlog::error("[CRITICAL] Memory allocation failed (std::bad_alloc)");
+    std::terminate();  // invokes terminate handler
+  }
+
+  /// @brief Signal handler (async-signal-safe)
+  static void handle_signal(int sig) {
+    constexpr char prefix[] = "CRITICAL: Fatal signal caught: ";
+    constexpr char suffix[] = "\n";
+    char buf[64];
+    size_t len = 0;
+
+    // copy prefix
+    for (char c : prefix) {
+      buf[len++] = c;
+    }
+
+    // convert signal number
+    int_to_str(sig, buf, len);
+
+    // copy suffix
+    for (char c : suffix) {
+      buf[len++] = c;
+    }
+
+    // write to stderr and exit
+    [[maybe_unused]] ssize_t n = write(2, buf, len);
+    _exit(1);
+  }
+
+  /// @brief Setup function
+  static void setup_crash_handlers() {
+    // Catch unhandled exceptions
+    std::set_terminate(handle_terminate);
+    // Catch std::bad_alloc (new OOM)
+    std::set_new_handler(handle_bad_alloc);
+    // Catch common fatal signals
+    std::signal(SIGSEGV, handle_signal);  // invalid memory access
+    std::signal(SIGABRT, handle_signal);  // abort()
+    std::signal(SIGFPE, handle_signal);   // divide by zero
+    std::signal(SIGILL, handle_signal);   // illegal instruction
+#ifdef __unix__
+    std::signal(SIGBUS, handle_signal);  // bus error (POSIX)
+#endif
+    // SIGKILL and SIGSTOP cannot be caught
+  }
+
+ private:
+  static inline void int_to_str(int n, char* buf, size_t& len) {
+    if (n == 0) {
+      buf[len++] = '0';
+      return;
+    }
+    char tmp[16];
+    int i = 0;
+    while (n > 0 && i < 16) {
+      tmp[i++] = '0' + (n % 10);
+      n /= 10;
+    }
+    // reverse digits
+    for (int j = i - 1; j >= 0; --j) {
+      buf[len++] = tmp[j];
+    }
+  }
+};
+
+}  // namespace utils