Discussion :

[marietar]

Bonjour
j'ai un programme main.py où j'utilise le package logging:

dans le main.py, j'ai cet extrait:

Code :

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

1
2
3
4
5
6
7
8
9
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.DEBUG,
                     format='%(name)s--%(levelname)s--%(message)s')
 
 
formatter = logging.Formatter('%(asctime)s--%(name)s--%(levelname)s--%(message)s')
file_handler = logging.FileHandler(f'{log_folder_path}/log.log', mode='w')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)

mon main.py marche bien, mais il est deguelasse.
j'ai défini des fonctions et j'aimerai mettre ces fonctions dans un module, puis demander au main.py d'importer ce module pour ensuite utiliser les fonctions
je créé alors un dossier utils et je mets le fichier helpers.py où je définis toutes les fonctions utilisées par main.py.

dans ce helper.py, j'aimerai aussi avoir un logger pour logger des infos.
je crée donc une fonction qui me crée le logger.
dans le main.py, je n'ai plus le code affiché au début, j'ai importé helpers.py donc j'appelle la fonction qui me crée le logger.

puis je me dis que les fonctions que j'ai créées dans helpers devraient aussi appeler la fonction qui créé le helper pour avoir de slogs quand me fonctions s'executent.

est-ce une bonne pratique de faire ca?
ca semble un peu casse guele à programmer non?

[papajoker]

bonjour

les fonctions que j'ai créées dans helpers devraient aussi appeler la fonction qui créé le helper pour avoir de slogs quand me fonctions s'executent.

Désolé je ne comprends pas le sens de la question, mais ce que tu sembles décrire en structure de fichiers est justement le premier exemple donné dans la doc python ... Tu désires réinventer la roue ou tu ne fais pas confiance à la doc ?

[marietar]

merci, j'ai essayé de siuvr ela doc mais j'ai toujour sun souci:
j'ai un dossier essai_logging.
dans ce dossier, j'ai le dossier 'app'

Dans ce dossier app, j'ia le script main.py:

Code :

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

1
2
3
4
5
6
7
import logging
from utils.helpers import function1
from utils.config_logger import init_logger
logger0 = logging.getLogger(__name__)
logger1 = init_logger(logger0)
function1()
logger1.info("etape2")

dans le dossier app, j'ai ensuite un dossier utils avec 2 scripts où j'ai les fonctions appelées par main.py:
pour init_logger.py :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
import logging
 
def init_logger(logger):
    logger.setLevel(logging.INFO)
    logging.basicConfig(level=logging.DEBUG,
                        format='%(name)s--%(levelname)s--%(message)s')
 
    formatter = logging.Formatter('%(asctime)s--%(name)s--%(levelname)s--%(message)s')
    file_handler = logging.FileHandler(f'app/log/log.log', mode='w')
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)
 
    return logger

pour helpers.py:

Code :

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

1
2
3
4
5
6
7
8
9
import logging
from utils.config_logger import init_logger
 
loggerZZ = logging.getLogger(__name__)
logger2 = init_logger(loggerZZ)
 
def function1():
    logger2.warning("AZETRYUUU")
    pass

quand je lance main.py:
dans la console tout s'affiche bien:

utils.helpers--WARNING--AZETRYUUU
__main__--INFO--etape2

mais dans le fihcier log, j'ia ca:

2024-07-16 21:48:32,022--__main__--INFO--etape2
-AZETRYUUU

pourquoi le ifchier log s'affiche mal?

[papajoker]

1er point

pourquoi toutes ces variables loggerX ... loggerY boujour la complexité sans raison

La simplicité, c'est de créer par exemple une simple fonction qui prend en paramètre le nom du module :

Code :

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

1
2
3
4
5
6
7
8
def init_logger(name):
   logger = logging.getLogger(name)
   ...
   return logger
 
# dans chaque fichier (même le main),on a qu'un seul appel :
logger = init_logger(__name__)
# donc, par simplicité, on va utiliser partout le même nom de variable

pourquoi le fichier log s'affiche mal?

Car tu as, dans ton code, plusieurs "file_handler" ! Donc tu vas écrire en même temps dans un même fichier ouvert plusieurs fois

Une façon de n'avoir qu'un seul fichier log ouvert est

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
def init_logger(name):
    if name != "__main__":
        name = f"__main__.{name}"    # les modules ont un parent
    logger = logging.getLogger(name)
    logger.setLevel(logging.DEBUG)
    logging.basicConfig(level=logging.DEBUG, format='%(name)s--%(levelname)s--%(message)s')
 
    if name != "__main__":    # les modules n'ont pas leur propre log d'ouvert, ils utilisent le parent (__main__)
        return logger    
    formatter = logging.Formatter('%(asctime)s -- %(name)s -- %(levelname)s -- %(message)s')
    file_handler = logging.FileHandler('app/log/log.log', mode='w')
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)
 
    return logger

[marietar]

je ne vois pas à quel moment j'ai plusieurs file handler.
le file handler est déifni dans ma fonction non?

et pourquoi tu testes deux fois if name != "__main__":

[papajoker]

je ne vois pas à quel moment j'ai plusieurs file handler.

si tu ne vois pas que tu appelles logger.addHandler() à chaque fois dans ta fonction "init_logger", donc un appel dans chaque module, je ne peux rien pour toi.

le file handler est déifni dans ma fonction non?
et pourquoi tu testes deux fois if name != "__main__":

C'est ton code
J'ai mis des commentaires pour ces 2 "if", comme dit précédemmment, tu cherches à faire un truc sorti de ton imagination au lieu de faire ce qui est préconisé dans la doc ! j'ai donc dû faire ces pirouettes pour palier.

merci, j'ai essayé de siuvr ela doc

ps: merci pour le francais bien compréhensible

Et non , tu n'as en rien suivi la doc ! ton exemple, trés très très proche de la doc, peut s'écrire:

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
import logging
from utils.helpers import function1
 
logger = logging.getLogger("APP")
logger.setLevel(logging.DEBUG)
logging.basicConfig(format='%(name)s -> %(levelname)s ->%(message)s')
formatter = logging.Formatter('%(asctime)s -- %(name)s [%(levelname)s] %(message)s')
file_handler = logging.FileHandler(f'log.log', mode='w')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
 
if __name__ == "__main__":
    print("hello")
    logger.info("etape0")
    function1()

Dans chaque module, on suit simplement la doc ...

Code :

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

1
2
3
4
5
import logging
logger = logging.getLogger(f"APP.{__name__}")
 
def function1():
    logger.warning("fonction1()")

ici:
- logger.addHandler() est appelé bien qu'une seule et unique fois ! dans main.py
- les "logger" ont le même parent (donc les modules héritent du principal "APP.")
ps: comme écrit dans mon code précédent, ces 2 choses sont faites par mes if "__main__" dans ton code ...

[marietar]

j'ai l'impression qu'il y a nue histoire de hierarchie avec ton code.
Tu as un logger nommé app pour le main et un logger nommé app.qqchose pour la fonction, ce logger app.qqchose est un fils du logger app.

Je voulais fairre un code ou mes deux loggers sont au meme niveau, c'est peut etre pour ca que ca marche pas chez moi?

[wiztricks]

Salut,

Je voulais fairre un code ou mes deux loggers sont au meme niveau, c'est peut etre pour ca que ca marche pas chez moi?

Non car ils seraient alors fils du logger racine qui existe toujours. C'est documenté dans le tuto qui vient avec la documentation dans les 2 derniers paragraphes du chapitre Loggers.
Et ça se teste facilement:

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
import logging
 
 
logger = logging.getLogger("APP")
logger.setLevel(logging.DEBUG)
logging.basicConfig(format='%(name)s -> %(levelname)s ->%(message)s')
formatter = logging.Formatter('%(asctime)s -- %(name)s [%(levelname)s] %(message)s')
file_handler = logging.FileHandler(f'log.log', mode='w')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
 
logger2 = logging.getLogger('foo')
logger2.setLevel(logging.DEBUG)
 
 
 
if __name__ == "__main__":
    print("hello")
    logger.info("etape0")
    logger2.info('etape0')

Après utiliser un module un peu compliqué sans avoir une représentation opérante de son fonctionnement, à vous de muscler votre activité d'apprentissage.

- W

[marietar]

bah je decouvre le module, faut bien commencer à un moment donné. et La doc est trop mal faite

[wiztricks]

La doc est trop mal faite

La documentation vient avec des tutos. qui donnent des exemples sur les cas d'utilisations les plus courants.

Lire une documentation un peu technique, c'est arriver à coder quelque chose qui "fonctionne" montrant qu'on a un peu compris quelque chose a ce qu'on a lu. Et quand çà ne marche pas, c'est qu'on a compris quelque chose de travers et qu'il faudra relire sa documentation pour essayer de comprendre son erreur.

C'est comme ça qu'on progresse... et qu'on s'adapte à la qualité variable des documentations qui viennent avec les outils qu'on utilise.

- W