logger.hpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS MCU software
 *
 *  Copyright (C) 2023, Libre Space Foundation <http://libre.space>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  SPDX-License-Identifier: GNU General Public License v3.0 or later
 */
#pragma once
 
#include <etl/circular_buffer.h>
#include <etl/string.h>
#include <initializer_list>
#include <satnogs-comms-lib/exception.hpp>
#include <string>
#include <zephyr/devicetree.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
 
#include "time.hpp"
namespace satnogs::comms
{

class logger
{
public:
  static constexpr const char *mcu_log_dir = "/SD" CONFIG_STORAGE_LOG_MCU_PATH;

  enum class target
  {
    RTT         = 0, 
    UART        = 1, 
    RING_BUFFER = 2, 
    STORAGE     = 3  
  };

  logger(logger const &) = delete;

  void
  operator=(logger const &) = delete;

  static logger &
  get_instance()
  {
    static logger instance;
    return instance;
  }
 
  void
  boot();
 
  void
  log(std::initializer_list<target> list, const lib::exception &e);
 
  void
  log(std::initializer_list<target> list, const std::exception &e);
 
  void
  log(std::initializer_list<target> list, const etl::exception &e);
 
  void
  log(std::initializer_list<target> list, const char *msg);
 
  void
  log(const lib::exception &e);
 
  void
  log(const std::exception &e);
 
  void
  log(const etl::exception &e);
 
  void
  log(const char *msg);
 
  void
  log(const etl::istring &msg);
 
  etl::string<CONFIG_LOG_MAX_MSG_LEN>
  get_latest_exception() const;
 
  void
  delete_storage_logs(struct tm &start, struct tm &end);
 
  class ring_buf_msg
  {
  public:
    time::time_src                      m_t_src;
    uint64_t                            m_t_posix;
    etl::string<CONFIG_LOG_MAX_MSG_LEN> m_log;
 
    ring_buf_msg() : m_t_src(time::time_src::UPTIME), m_t_posix(0), m_log("") {}
 
    ring_buf_msg(time::time_src t_src, uint64_t t_posix,
                 const etl::string<CONFIG_LOG_MAX_MSG_LEN> &log)
        : m_t_src(t_src), m_t_posix(t_posix), m_log(log)
    {
    }
  };
 
  void
  get_ring_buffer_log(ring_buf_msg &data, size_t index);
 
  size_t
  get_ring_buffer_size();
 
private:
  template <typename T>
  void
  log_unlocked(std::initializer_list<target> list, const T &m)
  {
    for (auto i : list) {
      switch (i) {
      case target::RTT:
        rtt_push(m);
        break;
      case target::UART:
        uart_push(m);
        break;
      case target::RING_BUFFER:
        ring_buffer_push(m);
        break;
      case target::STORAGE:
        storage_push(m);
        break;
      default:
        break;
      }
    }
  }
 
  void
  rtt_push(const lib::exception &e);
 
  void
  rtt_push(const std::exception &e);
 
  void
  rtt_push(const etl::exception &e);
 
  void
  rtt_push(const char *msg);
 
  void
  ring_buffer_push(const lib::exception &e);
 
  void
  ring_buffer_push(const std::exception &e);
 
  void
  ring_buffer_push(const etl::exception &e);
 
  void
  ring_buffer_push(const char *msg);
 
  void
  uart_push(const lib::exception &e);
 
  void
  uart_push(const std::exception &e);
 
  void
  uart_push(const etl::exception &e);
 
  void
  uart_push(const char *msg);
 
  void
  storage_push(const lib::exception &e);
 
  void
  storage_push(const std::exception &e);
 
  void
  storage_push(const etl::exception &e);
 
  void
  storage_push(const char *msg);
 
  int
  backup_sram_push(const lib::exception &e);
 
  int
  backup_sram_push(const std::exception &e);
 
  int
  backup_sram_push(const etl::exception &e);
 
  logger();
 
  void
  current_log_file(etl::istring &path);

  etl::circular_buffer<ring_buf_msg, CONFIG_LOG_RING_BUFFER_MSGS> m_ring_buffer;
  mutable struct k_mutex m_mtx;
 
  etl::string<CONFIG_STORAGE_MAX_PATH_LEN> m_logs_path;
};
 
} // namespace satnogs::comms