logger.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2020-2024, NVIDIA CORPORATION.
 *
 * Licensed 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 <cuml/common/log_levels.hpp>
 
#include <stdarg.h>
 
#include <memory>
#include <mutex>
#include <sstream>
#include <string>
 
namespace spdlog {
class logger;
namespace sinks {
template <class Mutex>
class CallbackSink;
using callback_sink_mt = CallbackSink<std::mutex>;
};  // namespace sinks
};  // namespace spdlog
 
namespace ML {
 
std::string format(const char* fmt, va_list& vl);
std::string format(const char* fmt, ...);
class Logger {
 public:
  static Logger& get();
 
  void setLevel(int level);
 
  void setPattern(const std::string& pattern);
 
  void setCallback(void (*callback)(int lvl, const char* msg));
 
  void setFlush(void (*flush)());
 
  bool shouldLogFor(int level) const;
 
  int getLevel() const;
 
  std::string getPattern() const { return currPattern; }
 
  void log(int level, const char* fmt, ...);
 
  void flush();
 
 private:
  Logger();
  ~Logger() {}
 
  std::shared_ptr<spdlog::sinks::callback_sink_mt> sink;
  std::shared_ptr<spdlog::logger> logger;
  std::string currPattern;
  static const std::string DefaultPattern;
};  // class Logger
 
class PatternSetter {
 public:
  PatternSetter(const std::string& pattern = "%v");
 
  ~PatternSetter();
 
 private:
  std::string prevPattern;
};  // class PatternSetter
 
#if (CUML_ACTIVE_LEVEL >= CUML_LEVEL_TRACE)
#define CUML_LOG_TRACE(fmt, ...)                               \
  do {                                                         \
    std::stringstream ss;                                      \
    ss << ML::format("%s:%d ", __FILE__, __LINE__);            \
    ss << ML::format(fmt, ##__VA_ARGS__);                      \
    ML::Logger::get().log(CUML_LEVEL_TRACE, ss.str().c_str()); \
  } while (0)
#else
#define CUML_LOG_TRACE(fmt, ...) void(0)
#endif
 
#if (CUML_ACTIVE_LEVEL >= CUML_LEVEL_DEBUG)
#define CUML_LOG_DEBUG(fmt, ...)                               \
  do {                                                         \
    std::stringstream ss;                                      \
    ss << ML::format("%s:%d ", __FILE__, __LINE__);            \
    ss << ML::format(fmt, ##__VA_ARGS__);                      \
    ML::Logger::get().log(CUML_LEVEL_DEBUG, ss.str().c_str()); \
  } while (0)
#else
#define CUML_LOG_DEBUG(fmt, ...) void(0)
#endif
 
#if (CUML_ACTIVE_LEVEL >= CUML_LEVEL_INFO)
#define CUML_LOG_INFO(fmt, ...) ML::Logger::get().log(CUML_LEVEL_INFO, fmt, ##__VA_ARGS__)
#else
#define CUML_LOG_INFO(fmt, ...) void(0)
#endif
 
#if (CUML_ACTIVE_LEVEL >= CUML_LEVEL_WARN)
#define CUML_LOG_WARN(fmt, ...) ML::Logger::get().log(CUML_LEVEL_WARN, fmt, ##__VA_ARGS__)
#else
#define CUML_LOG_WARN(fmt, ...) void(0)
#endif
 
#if (CUML_ACTIVE_LEVEL >= CUML_LEVEL_ERROR)
#define CUML_LOG_ERROR(fmt, ...) ML::Logger::get().log(CUML_LEVEL_ERROR, fmt, ##__VA_ARGS__)
#else
#define CUML_LOG_ERROR(fmt, ...) void(0)
#endif
 
#if (CUML_ACTIVE_LEVEL >= CUML_LEVEL_CRITICAL)
#define CUML_LOG_CRITICAL(fmt, ...) ML::Logger::get().log(CUML_LEVEL_CRITICAL, fmt, ##__VA_ARGS__)
#else
#define CUML_LOG_CRITICAL(fmt, ...) void(0)
#endif
};  // namespace ML