vart_logger.hpp

Go to the documentation of this file.

/*
 * Copyright 2024-2026 Advanced Micro Devices Inc.
 *
 * 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 <syslog.h>
#include <chrono>
#include <cstdarg>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <map>
#include <memory>
#include <mutex>
#include <sstream>
#include <string>
#include "vart_logger_types.hpp"
 
namespace vart {
 
// Below 'obj' object is created as static object and shared by all the
// components when header file is included
#define VART_LOG_REGISTER(x, y) obj.mod_register(x, y);
 
#define VART_LOG_ERR_OBJ(x, ...)                                                                        \
  do {                                                                                                  \
    if (x) {                                                                                            \
      obj.vart_logger_log_obj(LogLevel::LOG_LEVEL_ERROR, x, __FILE__, __func__, __LINE__, __VA_ARGS__); \
    }                                                                                                   \
  } while (0)
 
#define VART_LOG_WARN_OBJ(x, ...)                                                                         \
  do {                                                                                                    \
    if (x) {                                                                                              \
      obj.vart_logger_log_obj(LogLevel::LOG_LEVEL_WARNING, x, __FILE__, __func__, __LINE__, __VA_ARGS__); \
    }                                                                                                     \
  } while (0)
 
#define VART_LOG_INFO_OBJ(x, ...)                                                                      \
  do {                                                                                                 \
    if (x) {                                                                                           \
      obj.vart_logger_log_obj(LogLevel::LOG_LEVEL_INFO, x, __FILE__, __func__, __LINE__, __VA_ARGS__); \
    }                                                                                                  \
  } while (0)
 
#define VART_LOG_DEBUG_OBJ(x, ...)                                                                      \
  do {                                                                                                  \
    if (x) {                                                                                            \
      obj.vart_logger_log_obj(LogLevel::LOG_LEVEL_DEBUG, x, __FILE__, __func__, __LINE__, __VA_ARGS__); \
    }                                                                                                   \
  } while (0)
 
static const int sys_log_level[] = {0, LOG_ERR, LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG};
class Logger {
 public:
  static Logger& get_instance() {
    static Logger log_obj;
    return log_obj;
  }
 
  std::shared_ptr<struct log_context> mod_register(const char* modname, bool need_id);
 
  void vart_logger_log_obj(LogLevel,
                           std::shared_ptr<struct log_context> ctx,
                           const char* filename,
                           const char* func,
                           uint32_t line,
                           const char* fmt,
                           ...);
 
  void set_backend(const LogBackend *backend);
 
 private:
  Logger();
  ~Logger();
  Logger(const Logger&) = delete;
  void operator=(const Logger&) = delete;
  LogLevel global_log_level;
  LogLevel level;
  LogType type;
  std::mutex reg_mutex;
  std::mutex log_mutex;
  std::map<std::string, std::tuple<int16_t, uint16_t>> vart_components;
  std::chrono::high_resolution_clock::time_point logger_start_time;
  std::FILE* log_file;
  LogBackend backend;
  bool backend_installed = false;
};
 
static Logger& obj = Logger::get_instance();
 
}  // namespace vart