log.h

Go to the documentation of this file.

#ifndef FASTLY_LOG_H
#define FASTLY_LOG_H
 
#include <fastly/error.h>
#include <fastly/sdk-sys.h>
#include <format>
#include <string>
#include <string_view>

namespace fastly::log {
 
using LogLevel = fastly::sys::log::LogLevel;
using LogLevelFilter = fastly::sys::log::LogLevelFilter;

template <typename... Args>
void error(std::format_string<Args...> fmt, Args &&...args) {
  fastly::sys::log::f_log_log(fastly::sys::log::LogLevel::Error,
                              std::format(fmt, std::forward<Args>(args)...));
}

template <typename... Args>
void error_to(std::string_view dest, std::format_string<Args...> fmt,
              Args &&...args) {
  fastly::sys::log::f_log_log_to(static_cast<std::string>(dest),
                                 fastly::sys::log::LogLevel::Error,
                                 std::format(fmt, std::forward<Args>(args)...));
}

template <typename... Args>
void warn(std::format_string<Args...> fmt, Args &&...args) {
  fastly::sys::log::f_log_log(fastly::sys::log::LogLevel::Warn,
                              std::format(fmt, std::forward<Args>(args)...));
}

template <typename... Args>
void warn_to(std::string_view dest, std::format_string<Args...> fmt,
             Args &&...args) {
  fastly::sys::log::f_log_log_to(static_cast<std::string>(dest),
                                 fastly::sys::log::LogLevel::Warn,
                                 std::format(fmt, std::forward<Args>(args)...));
}

template <typename... Args>
void info(std::format_string<Args...> fmt, Args &&...args) {
  fastly::sys::log::f_log_log(fastly::sys::log::LogLevel::Info,
                              std::format(fmt, std::forward<Args>(args)...));
}

template <typename... Args>
void info_to(std::string_view dest, std::format_string<Args...> fmt,
             Args &&...args) {
  fastly::sys::log::f_log_log_to(static_cast<std::string>(dest),
                                 fastly::sys::log::LogLevel::Info,
                                 std::format(fmt, std::forward<Args>(args)...));
}

template <typename... Args>
void debug(std::format_string<Args...> fmt, Args &&...args) {
  fastly::sys::log::f_log_log(fastly::sys::log::LogLevel::Debug,
                              std::format(fmt, std::forward<Args>(args)...));
}

template <typename... Args>
void debug_to(std::string_view dest, std::format_string<Args...> fmt,
              Args &&...args) {
  fastly::sys::log::f_log_log_to(static_cast<std::string>(dest),
                                 fastly::sys::log::LogLevel::Debug,
                                 std::format(fmt, std::forward<Args>(args)...));
}

template <typename... Args>
void trace(std::format_string<Args...> fmt, Args &&...args) {
  fastly::sys::log::f_log_log(fastly::sys::log::LogLevel::Trace,
                              std::format(fmt, std::forward<Args>(args)...));
}

template <typename... Args>
void trace_to(std::string_view dest, std::format_string<Args...> fmt,
              Args &&...args) {
  fastly::sys::log::f_log_log_to(static_cast<std::string>(dest),
                                 fastly::sys::log::LogLevel::Trace,
                                 std::format(fmt, std::forward<Args>(args)...));
}

void set_max_level(LogLevelFilter level);

LogLevelFilter max_level();
 
class LoggerBuilder;

class Endpoint {
  friend LoggerBuilder;
  friend void init_simple(Endpoint endpoint, LogLevelFilter level);
 
public:
  std::string name();

  static fastly::expected<Endpoint> from_name(std::string_view name);
 
private:
  Endpoint(rust::Box<fastly::sys::log::Endpoint> e) : ep(std::move(e)) {};
  rust::Box<fastly::sys::log::Endpoint> ep;
};

void init_simple(Endpoint endpoint, LogLevelFilter level);
void init_simple(std::string_view endpoint, LogLevelFilter level);
void init_simple(Endpoint endpoint);
void init_simple(std::string_view endpoint);

class LoggerBuilder {
public:
  LoggerBuilder() : lb(fastly::sys::log::m_static_log_logger_builder_new()) {}

  LoggerBuilder endpoint(Endpoint endpoint) &&;
  LoggerBuilder endpoint(std::string_view endpoint) &&;

  LoggerBuilder endpoint_level(Endpoint endpoint, LogLevelFilter level) &&;
  LoggerBuilder endpoint_level(std::string_view endpoint,
                               LogLevelFilter level) &&;

  LoggerBuilder default_endpoint(Endpoint endpoint) &&;
  LoggerBuilder default_endpoint(std::string_view endpoint) &&;

  LoggerBuilder default_level_endpoint(Endpoint endpoint, LogLevel level) &&;
  LoggerBuilder default_level_endpoint(std::string_view endpoint,
                                       LogLevel level) &&;

  LoggerBuilder max_level(LogLevelFilter level) &&;

  LoggerBuilder echo_stdout(bool enabled) &&;

  LoggerBuilder echo_stderr(bool enabled) &&;

  void init();
 
private:
  LoggerBuilder(rust::Box<fastly::sys::log::LoggerBuilder> l)
      : lb(std::move(l)) {};
  rust::Box<fastly::sys::log::LoggerBuilder> lb;
};
 
} // namespace fastly::log
 
#endif