Bibliothèque de journalisation pour C

Question

Je suis à la recherche d'une bibliothèque de journalisation productive et simple pour le langage C, qui peut produire le journal dans un fichier. L'affichage des messages dans le log que je veux faire ressemble à ceci :

date-time tag message

Il serait intéressant de contrôler le niveau de détail des messages et la taille du fichier.

J'ai trouvé deux projets qui me conviennent. Il s'agit de log4c y nglogc .

log4c semble trop gros. nglogc convient assez bien, mais a aussi une fonction redondante. peut-être me direz-vous plus de variantes ?

Answer 1

Vous pouvez utiliser cette

Fichier logger.h

#ifndef LOGGER_H
#define LOGGER_H

void logger(const char* tag, const char* message);

#endif /* LOG_H */

Fichier logger.c

#include "logger.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void logger(const char* tag, const char* message) {
   time_t now;
   time(&now);
   printf("%s [%s]: %s\n", ctime(&now), tag, message);
}

Ce n'est sans doute pas parfait, mais cela répond aux besoins tels que vous les avez présentés.

Answer 2

Je suggère la bibliothèque de logs que j'ai moi-même écrite --- zlog !

La façon de répondre à votre besoin en matière de zlog est la suivante :

$ vi /etc/zlog.conf
[formats]
simple = "%D %c %m%n"
# don't know what the tag mean in your question, so put category of zlog instead
# log level is also available here, add %V means level

[rules]
my_cat.*   "xxx.log"; simple

$ vi hello.c
#include <stdio.h> 
#include "zlog.h"

int main(int argc, char** argv)
{
int rc;
zlog_category_t *c;

rc = dzlog_init("/etc/zlog.conf", "my_cat");
if (rc) {
    printf("init failed\n");
    return -1;
}

zlog_info(c, "hello, zlog");

zlog_fini();

return 0;
} 

Il génère xxx.log dans le répertoire courant sous la forme suivante

2012-09-30 07:22:50 my_cat hello, zlog

Liens :

Télécharger : https://github.com/HardySimpson/zlog/archive/latest-stable.tar.gz

Guide de l'utilisateur : http://hardysimpson.github.com/zlog/UsersGuide-EN.html

Hompage : http://hardysimpson.github.com/zlog/

Answer 3

Here is mine:

log.h
------

#ifndef LOG_H 
#define LOG_H

void log_error(const char* message, ...); void log_info(const char* message, ...); void log_debug(const char* message, ...);

#endif

log.c
------
#include "log.h"

void log_format(const char* tag, const char* message, va_list args) {   time_t now;     time(&now);     char * date =ctime(&now);   date[strlen(date) - 1] = '\0';  printf("%s [%s] ", date, tag);  vprintf(message, args);     printf("\n"); }

void log_error(const char* message, ...) {  va_list args;   va_start(args, message);    log_format("error", message, args);     va_end(args); }

void log_info(const char* message, ...) {   va_list args;   va_start(args, message);    log_format("info", message, args);  va_end(args); }

void log_debug(const char* message, ...) {  va_list args;   va_start(args, message);    log_format("debug", message, args);     va_end(args); }

Amusez-vous bien !

Answer 4

Vous pouvez utiliser cette bibliothèque de journalisation simple : https://github.com/kala13x/slog

Voici un exemple d'utilisation :

Vous devez d'abord initialiser le journal à l'aide de la fonction init_log(). Le premier argument est le nom du fichier d'enregistrement, le deuxième argument est l'enregistrement dans le fichier (1 activé, 0 désactivé) et le troisième argument est le niveau d'enregistrement maximum.

init_slog("example", 1, 3);

imprimer et enregistrer quelque chose

slog(0, "Test message with level 0");
slog(2, "Test message with level 2");
slog(0, "Test message with int argument: %d", int_arg);

Outout sera quelque chose comme ça :

2015:04:02:56 - Message de test avec le niveau 0
2015:04:02:56 - Message de test avec le niveau 2
2015:04:02:56 - Message de test avec argument int : 69

Answer 5

Jetez un coup d'œil à la zf_log bibliothèque d'enregistrement. Elle est petite, simple et ne fournit que l'essentiel. Extrait du fichier README.md :

Il s'agit simplement d'une enveloppe fine autour de la fonction sprintf(). Elle fournit moins de 20 % des fonctionnalités que l'on trouve dans des bibliothèques plus sophistiquées, mais couvre plus de 80 % des cas d'utilisation courants. L'accent est mis sur la simplicité, la facilité d'utilisation et la performance (pour être plus précis - faible surcharge).

Caractéristiques :

• La journalisation de débogage est réduite à no-op dans les versions release.
• Les arguments ne sont pas évalués lorsque le message n'est pas enregistré.
• Pas d'avertissement "inutilisé" pour les variables utilisées uniquement dans les déclarations d'enregistrement
• Enregistrer une région de mémoire en HEX et ASCII
• Fonctions de sortie personnalisées