Discussion :

[Ganondorf]

bonsoir, bonjour ? à tous,

Comme le dit l'intitulé je cherche a optimiser une partie de code que j'ai faite.
Il s'agit d'un système de log, le code fonctionne mais j'ai peur qu'il soit vite dépassé par les evenements. En effet il se peut qu'a l'avenir il est a loguer une 100enes (voir plus) de messages a la minute et ce que j'ai fais est assez primitif, ouverture et fermeture a chaque appel de la fonction etc ...

voici le code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
static char *getfileofday(void)
{
	static char buf[25];
	struct tm *tm;
	time_t now;
 
	now = time(NULL);
	tm = localtime(&now);
 
	strftime(buf, sizeof(buf), "logs/services.%Y-%m-%d", tm);
	return buf;
}
 
 
int irclog(unsigned int flags, const char *fmt, ...)
{
	va_list ap;
	char buf[BUFSIZE];
	FILE *fp;
	size_t len;
	char *filename = getfileofday();
 
	va_start(ap, fmt);
	len = vsprintf(buf, fmt, ap);
	va_end(ap);
 
	buf[len++] = '\n';
	buf[len] = 0;
 
	if (flags & LOG_FILE) {
 
		if ((fp = file_create(filename))) {
			fprintf(fp, buf);
			fclose(fp);
		}
		else return irclog(LOG_TTY, "irclog(); can't open log file '%s'", filename);
	}
 
	if ((flags & LOG_TTY) && isatty(1))
		puts(buf);
 
	return 0;
}

J'aimerai beaucoup vos avis la dessus, et sinon comment vous feriez ?

[Invité(e)]

Bonjour,

J'aimerai beaucoup vos avis la dessus, et sinon comment vous feriez ?

En général, quand je fait un système de log, j'ai

• une fonction d'init qui ouvre un fichier de log qui sera utilisé dans le programme, une fonction d'écriture et
• une fonction de fermeture :

Code log.h :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
void LOG_init(const char * filename);
void LOG_close(void);
void LOG_log(const char *message);

Code log.c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>
#include "log.h"
FILE * s_log = NULL;
void LOG_init(const char * filename) {
    LOG_close(); 
    s_log = fopen(filename, "w");
}
 
void LOG_close(void) {
    if(NULL != s_log) {
        fclose(s_log);
        s_log = NULL;
    }
}
 
void LOG_log(const char *message) {
    if(NULL != s_log) {
        fputs(message, s_log);
        fflush(s_log);
    } else {
        fputs(message, stderr);
    }
}

Mais tu peux aussi, et c'est certainement mieux pour un usage pro, utiliser des systèmes comme syslog ou winlog.

[Ganondorf]

merci bien mabu, je vais m'aider de ca

[LittleWhite]

Bonjour,

Dans le design général, je suis d'accord avec mabu, et c'est une solution relativement simple .
Par contre, personnellement, lorsque je cherche à faire un log (et je cherche en ce moment), c'est que celui soit:

• Facilement accessible de partout dans le programme
• Possibilité d'écrire dans plusieurs fichiers (pas le même message)
• Possibilité d'avoir un niveau de priorité dans le système
• Optionnel à un certain point: Non sensible aux threads

Maintenant, il n'y a pas de miracle pour le premier point. Il faudra passer le log, soit à toutes les fonctions qui en ont besoin, soit faire la variable globale.
Le problème de la variable globale est que cela limite souvent le nombre de sorties (cas de mabu)
(En C++, on peut s'arranger un peu mieux :p (et je ne parle pas de Singleton))

Dans le cas de mabu, on peut écrire dans plusieurs fichiers, si nécessaires. Par contre, le premier fichier doit être fermer pour écrire dans le deuxième.
On peut imaginer une solution qui, lors du log, on passe en paramètre la sortie vers laquelle on veut logguer. (Rappel, stdout est aussi un FILE* )
Pour le système de priorité (ou importance) juste l'intégration de plusieurs fonctions de log (warning, severe, info) suffit
Finalement, la sensibilité aux threads (thread safe), c'est pour les cas où l'on pense avoir à implémenter les threads, et ce réglera avec les mutex / sémaphores (ou autre technique de synchronisation).

Finalement, je suis à penser qu'il faille mieux utiliser une bibliothèque de logging pour éviter de crée des bugs ... dans un outils aidant au debugguage