Sink.h

#pragma once

#include "quill/core/Attributes.h"
#include "quill/core/LogLevel.h"
#include "quill/core/PatternFormatterOptions.h"
#include "quill/core/QuillError.h"
#include "quill/core/Spinlock.h"
#include "quill/filters/Filter.h"

#include <algorithm>
#include <atomic>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

QUILL_BEGIN_NAMESPACE

namespace detail
{
class BackendWorker;
}

QUILL_BEGIN_EXPORT

class MacroMetadata;
class MetricMetadata;
class PatternFormatter;

QUILL_END_EXPORT

QUILL_BEGIN_EXPORT
class Sink
{
public:
  explicit Sink(std::optional<PatternFormatterOptions> override_pattern_formatter_options = std::nullopt)
    : _override_pattern_formatter_options(std::move(override_pattern_formatter_options))
  {
  }

  virtual ~Sink() = default;

  Sink(Sink const&) = delete;
  Sink& operator=(Sink const&) = delete;

  void set_log_level_filter(LogLevel log_level)
  {
    _log_level.store(log_level, std::memory_order_relaxed);
  }

  QUILL_NODISCARD LogLevel get_log_level_filter() const noexcept
  {
    return _log_level.load(std::memory_order_relaxed);
  }

  void add_filter(std::unique_ptr<Filter> filter)
  {
    if (QUILL_UNLIKELY(!filter))
    {
      QUILL_THROW(QuillError{"Filter pointer is nullptr"});
    }

    // Call the user-overridable name accessor before taking the lock.
    std::string filter_name = filter->get_filter_name();

    // Lock and add this filter to our global collection
    detail::LockGuard const lock{_global_filters_lock};

    // Check if the same filter already exists
    auto const search_filter_it = std::find_if(_global_filters.cbegin(), _global_filters.cend(),
                                               [&filter_name](RegisteredFilter const& elem_filter)
                                               { return elem_filter.filter_name == filter_name; });

    if (QUILL_UNLIKELY(search_filter_it != _global_filters.cend()))
    {
      QUILL_THROW(QuillError{"Filter with the same name already exists"});
    }

    _global_filters.emplace_back(std::move(filter_name), std::move(filter));

    // Indicate a new filter was added - here relaxed is okay as the spinlock will do acq-rel on destruction
    _new_filter.store(true, std::memory_order_relaxed);
  }

protected:
  QUILL_ATTRIBUTE_HOT virtual void write_log(
    MacroMetadata const* log_metadata, uint64_t log_timestamp, std::string_view thread_id,
    std::string_view thread_name, std::string const& process_id, std::string_view logger_name,
    LogLevel log_level, std::string_view log_level_description, std::string_view log_level_short_code,
    std::vector<std::pair<std::string, std::string>> const* named_args,
    std::string_view log_message, std::string_view log_statement) = 0;

  QUILL_ATTRIBUTE_HOT virtual void write_metric(MetricMetadata const* /* metric_metadata */,
                                                uint64_t /* log_timestamp */, std::string_view /* thread_id */,
                                                std::string_view /* thread_name */,
                                                std::string const& /* process_id */,
                                                std::string_view /* logger_name */, double /* value */)
  {
  }

  QUILL_ATTRIBUTE_HOT virtual void flush_sink() = 0;

  QUILL_ATTRIBUTE_HOT virtual void run_periodic_tasks() noexcept {}

  QUILL_NODISCARD bool apply_all_filters(MacroMetadata const* log_metadata, uint64_t log_timestamp,
                                         std::string_view thread_id, std::string_view thread_name,
                                         std::string_view logger_name, LogLevel log_level,
                                         std::string_view log_message, std::string_view log_statement)
  {
    if (log_level < _log_level.load(std::memory_order_relaxed))
    {
      return false;
    }

    // Update our local collection of the filters
    if (QUILL_UNLIKELY(_new_filter.exchange(false, std::memory_order_relaxed)))
    {
      // if there is a new filter we have to update
      _local_filters.clear();

      detail::LockGuard const lock{_global_filters_lock};

      for (auto const& filter : _global_filters)
      {
        _local_filters.push_back(filter.filter.get());
      }
    }

    if (_local_filters.empty())
    {
      return true;
    }
    else
    {
      return std::all_of(_local_filters.begin(), _local_filters.end(),
                         [log_metadata, log_timestamp, thread_id, thread_name, logger_name,
                          log_level, log_message, log_statement](Filter* filter_elem)
                         {
                           return filter_elem->filter(log_metadata, log_timestamp, thread_id, thread_name,
                                                      logger_name, log_level, log_message, log_statement);
                         });
    }
  }

private:
  friend class detail::BackendWorker;

  struct RegisteredFilter
  {
    RegisteredFilter(std::string filter_name_arg, std::unique_ptr<Filter> filter_arg)
      : filter_name(std::move(filter_name_arg)), filter(std::move(filter_arg))
    {
    }

    std::string filter_name;
    std::unique_ptr<Filter> filter;
  };

  std::optional<PatternFormatterOptions> _override_pattern_formatter_options; /* Set by the frontend and accessed by the backend to initialise PatternFormatter */
  std::shared_ptr<PatternFormatter> _override_pattern_formatter; /* The backend thread will set this once */

  std::vector<Filter*> _local_filters;

  std::vector<RegisteredFilter> _global_filters;
  detail::Spinlock _global_filters_lock;
  std::atomic<bool> _new_filter{false};

  std::atomic<LogLevel> _log_level{LogLevel::TraceL3};
};

QUILL_END_EXPORT

QUILL_END_NAMESPACE