logger.c File Reference

Implements logging functionality for the game. More...

#include "logger.h"
#include "../thread/thread_handler.h"
#include "logger_config.h"
#include "ringbuffer.h"
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <time.h>
#include <dirent.h>

Go to the source code of this file.

Macros
#define	STAT_STRUCT   struct stat
#define	STAT_FUNC   stat
#define	MKDIR(path)
#define	PATH_SEP   "/"
#define	MAX_PATH_SIZE   4096
#define	LOG_DIRECTORY   "log"
#define	LOG_FILE_FORMAT   "log-%d.txt"
#define	TIMESTAMP_FORMAT   "%Y-%m-%d %H:%M:%S"
#define	MSG_FORMAT   "[%s] [%s] [%s] : %s\n"

Functions
int	ensure_log_dir (void)
	Ensures that the predefined log directory already exists, if not create a new one.
int	open_log_file (int is_init)
	Opens the log file with the current saved file id in appended modus.
int	check_log_file (void)
	This function should be called whenever a new log msg must be written.
int	get_latest_file_id (void)
	This function gets the latest file id from the log directory.
void	start_log_writer_thread (void)
	Starts the log writer thread.
void	log_writer_thread (void)
	This function will be called from a different thread to read from the ringbuffer and then write in the log file.
void	init_logger (void)
	Initializes the logging system for the application.
void	log_msg (const log_level_t level, const char *module, const char *format,...)
	Logs a formatted message with a specified log level and module.
void	shutdown_logger (void)
	Shuts down the logging system for the application.

Variables
const char *	log_level_str [] = {"DEBUG", "FINE", "INFO", "WARNING", "ERROR"}
FILE *	log_file = NULL
ring_buffer_t	log_buffer
bool	logger_is_running = false
int	file_id = 0

Detailed Description

Implements logging functionality for the game.

Definition in file logger.c.

Macro Definition Documentation

LOG_DIRECTORY

#define LOG_DIRECTORY   "log"

Definition at line 37 of file logger.c.

LOG_FILE_FORMAT

#define LOG_FILE_FORMAT   "log-%d.txt"

Definition at line 38 of file logger.c.

MAX_PATH_SIZE

#define MAX_PATH_SIZE   4096

Definition at line 34 of file logger.c.

MKDIR

#define MKDIR

(

path

)

Value:

mkdir(path, 0755)

Definition at line 30 of file logger.c.

MSG_FORMAT

#define MSG_FORMAT   "[%s] [%s] [%s] : %s\n"

Definition at line 41 of file logger.c.

PATH_SEP

#define PATH_SEP   "/"

Definition at line 31 of file logger.c.

STAT_FUNC

#define STAT_FUNC   stat

Definition at line 29 of file logger.c.

STAT_STRUCT

#define STAT_STRUCT   struct stat

Definition at line 28 of file logger.c.

TIMESTAMP_FORMAT

#define TIMESTAMP_FORMAT   "%Y-%m-%d %H:%M:%S"

Definition at line 40 of file logger.c.

Function Documentation

check_log_file()

int check_log_file

(

void

)

This function should be called whenever a new log msg must be written.

Check if the log file is open, if not, a new file will be open.

• Either by creating a new file if no file is in the log directory.
• Or creating a new file if the last used file reaches the max size. The new file will get the current file id + 1 or 0, if the id reached the max number of files.
• Or opening the file that was last used, the current id will be set.

  Returns

  0 if successfully, 1 if the current file was already closed, and a new file wasn't opened

Definition at line 144 of file logger.c.

                         {
    if (log_file) {
        fseek(log_file, 0, SEEK_END);
        const long file_size = ftell(log_file);
        if (file_size >= MAX_FILE_SIZE) {
            fclose(log_file);//close the current file
            file_id = (file_id + 1) % MAX_N_FILES;
 
            // open a new file
            if (open_log_file(1) != 0) {
                // failed to open a new file
                return 1;
            }
        }
    }
    return 0;
}

ensure_log_dir()

int ensure_log_dir

(

void

)

Ensures that the predefined log directory already exists, if not create a new one.

Returns

0 if successfully created or already exists, 1 if failed

Definition at line 105 of file logger.c.

                         {
    STAT_STRUCT st;
 
    if (STAT_FUNC(LOG_DIRECTORY, &st) == -1) {
        if (MKDIR(LOG_DIRECTORY) == -1) {
            return 1;
        }
    }
    return 0;
}

get_latest_file_id()

int get_latest_file_id

(

void

)

This function gets the latest file id from the log directory.

Returns

0 or greater if successfully, -1 if failed

Note

This function should only be called once when the logger is initialized.

Definition at line 162 of file logger.c.

                             {
    if (ensure_log_dir() != 0) {
        // failed to ensure the log directory
        return -1;
    }
 
    int latest_id = 0;
    DIR* dir = opendir(LOG_DIRECTORY);
    struct dirent* entry;
    time_t latest_time = 0;
 
    if (!dir) {
        // failed to open the log directory
        return -1;
    }
 
    // Iterate through the log directory and find the latest used file
    while ((entry = readdir(dir)) != NULL) {
        int id;
        struct stat file_stat;
 
        if (sscanf(entry->d_name, LOG_FILE_FORMAT, &id) == 1 && id >= 0 && id < MAX_N_FILES) {
            char filepath[MAX_PATH_SIZE];
            snprintf(filepath, sizeof(filepath), "%s/%s", LOG_DIRECTORY, entry->d_name);
 
            if (stat(filepath, &file_stat) == 0) {
                if (file_stat.st_mtime > latest_time) {
                    // found a newer file
                    latest_time = file_stat.st_mtime;
                    latest_id = id;
                }
            }
        }
    }
 
    closedir(dir);
    return latest_id;
}

init_logger()

void init_logger

(

void

)

Initializes the logging system for the application.

This function sets up the logging system to be ready for recording log entries. It creates or opens the log file, initializes the ring buffer used for storing log entries temporarily, and starts the thread that asynchronously writes logs to the file. This ensures logging is operational and ready to use for the application's lifetime.

Notes:

• This function can only be called once during the application's lifecycle. Subsequent calls will have no effect if the logger is already initialized.
• All required resources for logging, such as the log file and ring buffer, are prepared within this initialization process.
• If any of the initialization steps fail (e.g., ring buffer initialization or file operations), the function ensures cleanup of allocated resources.

Definition at line 232 of file logger.c.

                       {
    // ensures the init_logger can only be called when the file is null
    if (log_file == NULL) {
        if (init_ringbuffer(&log_buffer) == 0) {
            file_id = get_latest_file_id();
            if (file_id == -1 || open_log_file(0) != 0) {
                fclose(log_file);
            } else {
                start_log_writer_thread();
            }
        }
    }
}

log_msg()

void log_msg	(	log_level_t	level,
		const char *	module,
		const char *	format,
			... )

Logs a formatted message with a specified log level and module.

This function generates a log entry that includes a timestamp, log level, module name, and a custom message formatted using a variable argument list. The log message is written to a ring buffer for asynchronous processing.

Notes:

• The logging system must be initialized and running before using this function. Otherwise, the function will return without performing any operations.
• The log level determines the severity or importance of the message.

Parameters

level	The severity level of the log message (e.g., DEBUG, INFO, ERROR). If the provided log level exceeds the maximum defined levels, the INFO level will be used as a fallback.
module	A string identifying the module or component generating the log message.
format	A printf-style format string for the message content.
...	Additional arguments to be formatted into the log message according to the format string.

Definition at line 246 of file logger.c.

                                                                                   {
    if (log_file == NULL || !logger_is_running) {
        // logger is not initialized or not running
        return;
    }
 
    //get timestamp
    const time_t now = time(NULL);
    const struct tm* tm = localtime(&now);
 
    char timestamp[32];
    strftime(timestamp, sizeof(timestamp), TIMESTAMP_FORMAT, tm);
 
    const char* log_level;
    if (level >= MAX_LOG_LEVEL) {
        log_level = log_level_str[INFO];
    } else {
        log_level = log_level_str[level];
    }
 
    va_list args;
    va_start(args, format);
    char msg[MAX_MSG_SIZE - MAX_HEADER_SIZE];
    vsnprintf(msg, sizeof(msg), format, args);
 
    char log_msg[MAX_MSG_SIZE];
    snprintf(log_msg, MAX_MSG_SIZE, MSG_FORMAT, timestamp, log_level, module, msg);
    va_end(args);
 
    write_to_ringbuffer(&log_buffer, log_msg);
}

log_writer_thread()

void log_writer_thread

(

void

)

This function will be called from a different thread to read from the ringbuffer and then write in the log file.

Definition at line 207 of file logger.c.

                         {
    bool running = true;
    while (running) {
        char log_msg[MAX_MSG_SIZE];
        if (read_from_ringbuffer(&log_buffer, log_msg) == 0) {
            // message successfully read from the ringbuffer
            check_log_file();
            if (log_file) {
                fprintf(log_file, "%s", log_msg);
                fflush(log_file);
            }
        }
        if (!logger_is_running) {
            // thread must be terminated
            running = false;
        }
    }
    //closes all pressures
    if (log_file) {
        fclose(log_file);
        log_file = NULL;
    }
    free_ringbuffer(&log_buffer);
}

open_log_file()

int open_log_file

(

int

is_init

)

Opens the log file with the current saved file id in appended modus.

If the file already exists, it will be first removed and then created. If no file is found, create a new file corresponding to fopen(...).

Parameters

is_init

if 0, no existing file will be removed

Returns

0 if successfully opened, 1 if failed

Definition at line 117 of file logger.c.

                                     {
    char name[16];
    snprintf(name, sizeof(name), LOG_FILE_FORMAT, file_id);
 
    char filename[256];
    snprintf(filename, sizeof(filename), "%s" PATH_SEP "%s", LOG_DIRECTORY, name);
 
    if (is_init) {
        // Check if the file already exists
        FILE* existing_file = fopen(filename, "r");
        if (existing_file) {
            fclose(existing_file);
 
            // If the file already exists, remove it
            if (remove(filename) != 0) {
                return 1;
            }
        }
    }
 
    log_file = fopen(filename, "a");
    if (!log_file) {
        return 1;
    }
    return 0;
}

shutdown_logger()

void shutdown_logger

(

void

)

Shuts down the logging system for the application.

This function terminates the logging system, ensuring that no further log entries are recorded. It sets the logger's running state to false, effectively disabling any ongoing or future logging operations.

Use this function to cleanly release logging resources and mark the completion of logging operations at the end of the application's lifecycle or during application shutdown sequences.

Notes:

• Once this function is called, logging within the application will cease to function.
• This function should be called after all dependent systems and processes using the logger are finalized.

Definition at line 278 of file logger.c.

                           {
    logger_is_running = false;
}

start_log_writer_thread()

void start_log_writer_thread

(

void

)

Starts the log writer thread.

This function will be called from the logger initialization function.

Definition at line 201 of file logger.c.

                                   {
    logger_is_running = true;
 
    start_simple_thread(log_writer_thread);
}

Variable Documentation

file_id

int file_id = 0

Definition at line 103 of file logger.c.

log_buffer

ring_buffer_t log_buffer

Definition at line 98 of file logger.c.

log_file

FILE* log_file = NULL

Definition at line 97 of file logger.c.

log_level_str

const char* log_level_str[] = {"DEBUG", "FINE", "INFO", "WARNING", "ERROR"}

Definition at line 43 of file logger.c.

{"DEBUG", "FINE", "INFO", "WARNING", "ERROR"};

logger_is_running

bool logger_is_running = false

Definition at line 101 of file logger.c.