Backend.h

#pragma once

#include "quill/backend/BackendManager.h"
#include "quill/backend/BackendOptions.h"
#include "quill/backend/SignalHandler.h"
#include "quill/core/Attributes.h"
#include "quill/core/MetricManager.h"
#include "quill/core/QuillError.h"

#include <atomic>
#include <csignal>
#include <cstdint>
#include <cstdlib>
#include <mutex>

QUILL_BEGIN_NAMESPACE

QUILL_BEGIN_EXPORT

constexpr uint32_t VersionMajor{12};
constexpr uint32_t VersionMinor{0};
constexpr uint32_t VersionPatch{0};
constexpr uint32_t Version{VersionMajor * 10000 + VersionMinor * 100 + VersionPatch};

class Backend
{
public:
  QUILL_ATTRIBUTE_COLD static void start(BackendOptions const& options = BackendOptions{})
  {
    std::call_once(detail::BackendManager::instance().get_start_once_flag(),
                   [options]()
                   {
                     // Static-destruction ordering matters here because Backend::stop() runs via
                     // std::atexit. Any singleton the backend may touch during shutdown must be
                     // constructed before we register the atexit handler, otherwise it could be
                     // destroyed first and the backend could dereference freed state while draining
                     // queues.
                     //
                     // BackendManager construction already pins ThreadContextManager,
                     // SinkManager, and LoggerManager because BackendWorker stores references to
                     // them as members. SignalHandlerContext and MetricManager are not pinned that
                     // way, so construct them explicitly before atexit registration.
                     (void)detail::SignalHandlerContext::instance();
                     (void)detail::MetricManager::instance();

                     // Run the backend worker thread, we wait here until the thread enters the main loop
                     detail::BackendManager::instance().start_backend_thread(options);

                     // Set up an exit handler to call stop when the main application exits.
                     // always call stop on destruction to log everything. std::atexit seems to be
                     // working better with dll on windows compared to using ~LogManagerSingleton().
                     if (!detail::BackendManager::instance().is_atexit_registered())
                     {
                       detail::BackendManager::instance().set_atexit_registered();
                       std::atexit([]() { Backend::stop(); });
                     }
                   });
  }

  template <typename TFrontendOptions>
  QUILL_ATTRIBUTE_COLD static void start(BackendOptions const& backend_options,
                                         SignalHandlerOptions const& signal_handler_options)
  {
    std::call_once(
      detail::BackendManager::instance().get_start_once_flag(),
      [backend_options, signal_handler_options]()
      {
        // These flags are only read in the catch block; unused in no-exception builds.
        QUILL_MAYBE_UNUSED bool signal_handler_initialized{false};
#if defined(_WIN32)
        QUILL_MAYBE_UNUSED bool exception_handler_initialized{false};
#else
        sigset_t set, oldset;
        QUILL_MAYBE_UNUSED bool signal_mask_modified{false};
#endif
        QUILL_TRY
        {
          // See Backend::start(BackendOptions) for the shutdown-order rationale.
          // BackendManager construction already pins ThreadContextManager,
          // SinkManager, and LoggerManager through BackendWorker member references.
          (void)detail::MetricManager::instance();

#if defined(_WIN32)
          detail::init_exception_handler<TFrontendOptions>();
          exception_handler_initialized = true;
#else
          // We do not want the signal handler to run in the backend worker thread.
          // Block signals in the caller thread so the backend worker inherits that mask.
          sigfillset(&set);
          if (sigprocmask(SIG_SETMASK, &set, &oldset) != 0)
          {
            QUILL_THROW(QuillError{"Failed to block signals before starting the backend thread"});
          }
          signal_mask_modified = true;
          detail::init_signal_handler<TFrontendOptions>(signal_handler_options.catchable_signals);
          signal_handler_initialized = true;
#endif

          auto& signal_handler_context = detail::SignalHandlerContext::instance();
          signal_handler_context.logger_name = signal_handler_options.logger_name;
          signal_handler_context.excluded_logger_substrings = signal_handler_options.excluded_logger_substrings;
          signal_handler_context.signal_handler_timeout_seconds.store(signal_handler_options.timeout_seconds);

          // Run the backend worker thread, we wait here until the thread enters the main loop
          detail::BackendManager::instance().start_backend_thread(backend_options);

          // We need to update the signal handler with some backend thread details
          signal_handler_context.backend_thread_id.store(
            detail::BackendManager::instance().get_backend_thread_id());

#if defined(_WIN32)
        // nothing to do
#else
          // Unblock signals in the caller thread so subsequent threads do not inherit the blocked mask
          if (sigprocmask(SIG_SETMASK, &oldset, nullptr) != 0)
          {
            QUILL_THROW(
              QuillError{"Failed to restore the caller signal mask after backend startup"});
          }
          signal_mask_modified = false;
#endif

          // Set up an exit handler to call stop when the main application exits.
          // always call stop on destruction to log everything. std::atexit seems to be
          // working better with dll on windows compared to using ~LogManagerSingleton().
          if (!detail::BackendManager::instance().is_atexit_registered())
          {
            detail::BackendManager::instance().set_atexit_registered();
            std::atexit([]() { Backend::stop(); });
          }
        }
#if !defined(QUILL_NO_EXCEPTIONS)
        QUILL_CATCH(...)
        {
          if (signal_handler_initialized)
          {
            detail::restore_signal_handlers();
          }
  #if defined(_WIN32)
          if (exception_handler_initialized)
          {
            detail::deinit_exception_handler<TFrontendOptions>();
          }
  #else
          if (signal_mask_modified)
          {
            sigprocmask(SIG_SETMASK, &oldset, nullptr);
          }
  #endif
          throw;
        }
#endif
      });
  }

  QUILL_ATTRIBUTE_COLD static void stop()
  {
    uint32_t const backend_thread_id = detail::BackendManager::instance().get_backend_thread_id();
    if (QUILL_UNLIKELY((backend_thread_id != 0) && (backend_thread_id == detail::get_thread_id())))
    {
      QUILL_THROW(QuillError{"Backend::stop() cannot be called from the backend worker thread"});
    }

    detail::SignalHandlerContext::instance().backend_thread_id.store(0);
    detail::BackendManager::instance().stop_backend_thread();
#if defined(_WIN32)
    if (auto const fn = detail::SignalHandlerContext::instance().exception_handler_deinit_callback)
    {
      fn();
    }
#endif
    detail::deinit_signal_handler();
  }

  static void notify() noexcept { detail::BackendManager::instance().notify_backend_thread(); }

  QUILL_NODISCARD static bool is_running() noexcept
  {
    return detail::BackendManager::instance().is_backend_thread_running();
  }

  QUILL_NODISCARD static uint32_t get_thread_id() noexcept
  {
    return detail::BackendManager::instance().get_backend_thread_id();
  }

  QUILL_NODISCARD static uint64_t convert_rdtsc_to_epoch_time(uint64_t rdtsc_value)
  {
    return detail::BackendManager::instance().convert_rdtsc_to_epoch_time(rdtsc_value);
  }

  QUILL_ATTRIBUTE_COLD static ManualBackendWorker* acquire_manual_backend_worker()
  {
    ManualBackendWorker* manual_backend_worker{nullptr};

    // If a caller forgets to perform explicit ManualBackendWorker::shutdown(), the
    // ManualBackendWorker destructor can still drain queued metric events during static
    // destruction. Construct MetricManager before BackendManager so MetricMetadata stays alive
    // for that fallback drain path.
    (void)detail::MetricManager::instance();

    std::call_once(
      detail::BackendManager::instance().get_start_once_flag(), [&manual_backend_worker]() mutable
      { manual_backend_worker = detail::BackendManager::instance().get_manual_backend_worker(); });

    if (!manual_backend_worker)
    {
      QUILL_THROW(
        QuillError{"acquire_manual_backend_worker() can only be called once per process. "
                   "Additionally, it should not be "
                   "called when start() has already been invoked"});
    }

    return manual_backend_worker;
  }
};

QUILL_END_EXPORT

QUILL_END_NAMESPACE