logger.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#pragma once
 
 
#include <concepts>
#include <cstdlib>
#include <format>
#include <functional>
#include <memory>
#include <source_location>
#include <string>
#include <string_view>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "iceberg/iceberg_export.h"
#include "iceberg/logging/log_level.h"
#include "iceberg/result.h"
 
namespace iceberg {
 
struct ICEBERG_EXPORT LogAttribute {
  std::string key;
  std::string value;
};
 
struct ICEBERG_EXPORT LogMessage {
  LogLevel level = LogLevel::kOff;
  std::string message;
  std::source_location location = std::source_location::current();
  std::vector<LogAttribute> attributes;
 
  class Builder;
};
 
class ICEBERG_EXPORT LogMessage::Builder {
 public:
  explicit Builder(LogLevel level,
                   std::source_location location = std::source_location::current())
      : level_(level), location_(location) {}
 
  Builder& Message(std::string message) {
    message_ = std::move(message);
    return *this;
  }
 
  Builder& Attribute(std::string key, std::string value) {
    attributes_.push_back(LogAttribute{.key = std::move(key), .value = std::move(value)});
    return *this;
  }
 
  Builder& Location(std::source_location location) {
    location_ = location;
    return *this;
  }
 
  LogMessage Build() {
    return LogMessage{.level = level_,
                      .message = std::move(message_),
                      .location = location_,
                      .attributes = std::move(attributes_)};
  }
 
 private:
  LogLevel level_;
  std::string message_;
  // `location_` is a trivially copyable members no need to move.
  std::source_location location_;
  std::vector<LogAttribute> attributes_;
};
 
inline constexpr std::string_view kLevelProperty = "level";
inline constexpr std::string_view kPatternProperty = "pattern";
 
class ICEBERG_EXPORT Logger {
 public:
  virtual ~Logger() = default;
 
  virtual Status Initialize(
      const std::unordered_map<std::string, std::string>& properties) {
    if (auto it = properties.find(std::string(kLevelProperty)); it != properties.end()) {
      auto parsed = LogLevelFromString(it->second);
      if (!parsed) return std::unexpected(parsed.error());
      SetLevel(*parsed);
    }
    return {};
  }
 
  virtual bool ShouldLog(LogLevel level) const noexcept = 0;
 
  virtual void Log(LogMessage&& message) noexcept = 0;
 
  virtual void SetLevel(LogLevel level) noexcept = 0;
 
  virtual LogLevel level() const noexcept = 0;
 
  virtual void Flush() noexcept {}
 
  virtual bool IsNoop() const { return false; }
 
  static std::shared_ptr<Logger> Noop();
};
 
ICEBERG_EXPORT std::shared_ptr<Logger> GetDefaultLogger();
 
ICEBERG_EXPORT std::shared_ptr<Logger> GetCurrentLogger();
 
ICEBERG_EXPORT void SetDefaultLogger(std::shared_ptr<Logger> logger);
 
ICEBERG_EXPORT void SetDefaultLevel(LogLevel level);
 
using FatalHandler =
    std::function<void(const std::source_location&, std::string_view message)>;
 
ICEBERG_EXPORT void SetFatalHandler(FatalHandler handler);
 
ICEBERG_EXPORT FatalHandler GetFatalHandler();
 
class ICEBERG_EXPORT ScopedLogger {
 public:
  explicit ScopedLogger(std::shared_ptr<Logger> logger) noexcept;
  ~ScopedLogger();
 
  ScopedLogger(const ScopedLogger&) = delete;
  ScopedLogger& operator=(const ScopedLogger&) = delete;
  ScopedLogger(ScopedLogger&&) = delete;
  ScopedLogger& operator=(ScopedLogger&&) = delete;
 
 private:
  std::shared_ptr<Logger> previous_;
};
 
// ---------------------------------------------------------------------------
// Using the API directly (the ICEBERG_LOG_* macros that wrap this live in
// log_macros.h). Example: a custom sink, installed as the process default.
//
//   class MySink : public Logger {
//    public:
//     bool ShouldLog(LogLevel level) const noexcept override { return level >= level_; }
//     void Log(LogMessage&& m) noexcept override { write_line(m.message); }
//     void SetLevel(LogLevel level) noexcept override { level_ = level; }
//     LogLevel level() const noexcept override { return level_; }
//    private:
//     std::atomic<LogLevel> level_{LogLevel::kInfo};
//   };
//
//   SetDefaultLogger(std::make_shared<MySink>());   // install process-wide
//   SetDefaultLevel(LogLevel::kDebug);              // adjust the threshold
//
//   auto logger = GetDefaultLogger();               // borrow the current default
//   if (logger->ShouldLog(LogLevel::kInfo)) {
//     logger->Log(LogMessage{.level = LogLevel::kInfo, .message = "scan ready"});
//   }
//
//   // Or configure from catalog-style properties (applies the "level" key):
//   auto sink = std::make_shared<MySink>();
//   auto status = sink->Initialize({{std::string(kLevelProperty), "warn"}});  // -> kWarn
// ---------------------------------------------------------------------------
 
namespace internal {
 
ICEBERG_EXPORT std::unique_ptr<Logger> MakeNoopLogger();
 
ICEBERG_EXPORT const std::shared_ptr<Logger>& CurrentLogger() noexcept;
 
ICEBERG_EXPORT void Emit(Logger& logger, LogLevel level,
                         const std::source_location& location, std::string&& message);
 
ICEBERG_EXPORT void EmitFormatError(Logger& logger, LogLevel level,
                                    const std::source_location& location) noexcept;
 
template <typename... Args>
struct FmtWithLoc {
  std::format_string<Args...> fmt;
  std::source_location loc;
 
  template <typename T>
    requires std::convertible_to<const T&, std::format_string<Args...>>
  consteval FmtWithLoc(  // NOLINT(google-explicit-constructor): mirrors
                         // std::format_string
      const T& s, std::source_location loc = std::source_location::current())
      : fmt(s), loc(loc) {}
};
 
template <typename... Args>
void FormatAndEmit(Logger& logger, LogLevel level, const std::source_location& loc,
                   std::format_string<Args...> fmt, Args&&... args) noexcept {
  if (!logger.ShouldLog(level)) return;
  try {
    Emit(logger, level, loc, std::format(fmt, std::forward<Args>(args)...));
  } catch (...) {
    // Catch-all upholds the noexcept "logging never throws" guarantee: a
    // user-defined std::formatter may throw a non-std::exception type, and this
    // function is noexcept, so anything escaping here would call std::terminate.
    EmitFormatError(logger, level, loc);
  }
}
 
}  // namespace internal
 
template <typename... Args>
void Log(LogLevel level, internal::FmtWithLoc<std::type_identity_t<Args>...> fmt,
         Args&&... args) noexcept {
  const std::shared_ptr<Logger>& logger = internal::CurrentLogger();
  if (logger) {
    internal::FormatAndEmit(*logger, level, fmt.loc, fmt.fmt,
                            std::forward<Args>(args)...);
  }
}
 
template <typename... Args>
void Log(Logger& logger, LogLevel level,
         internal::FmtWithLoc<std::type_identity_t<Args>...> fmt,
         Args&&... args) noexcept {
  internal::FormatAndEmit(logger, level, fmt.loc, fmt.fmt, std::forward<Args>(args)...);
}
 
}  // namespace iceberg