Explication détaillée de l'utilisation du module de journalisation en Python dans un environnement multi-processus

De nombreuses applications disposeront d'un module de journalisation, qui est utilisé pour enregistrer certaines informations clés pendant le fonctionnement du système afin de faciliter le suivi de l'état de fonctionnement du système. Cet article présente principalement l'utilisation du module de journalisation en Python dans un environnement multi-processus. Les amis dans le besoin peuvent s'y référer.

Avant-propos

Je pense que tout programmeur devrait savoir que lors de l'utilisation de Python pour écrire des tâches en arrière-plan, il est souvent nécessaire d'utiliser des journaux de sortie pour enregistrer l'état du programme en cours d'exécution et pour signaler les erreurs en cas d'erreur. se produire. Les détails sont enregistrés pour un débogage et une analyse ultérieurs. Le module de journalisation de Python est d'une grande aide dans cette situation.

Le module de journalisation peut spécifier le niveau de journalisation, DEBUG, INFO, AVERTISSEMENT, ERREUR, CRITICAL Par exemple, pendant le développement et le débogage, les journaux avec des niveaux supérieurs à DEBUG peuvent être générés, alors que dans un environnement de production, uniquement INFO. peut être niveau de sortie. (S'il n'est pas spécifié, le niveau par défaut est avertissement)

journalisation Vous pouvez également spécifier la sortie vers la ligne de commande ou le fichier, et vous pouvez également diviser le fichier journal par heure ou par taille.

Concernant l'utilisation détaillée de la journalisation, je n'entrerai pas dans les détails ici. Vous pouvez vous référer à la documentation officielle ou à l'introduction ici.

Configuration de la journalisation

Normalement, nous devons enregistrer le journal dans un fichier et nous attendre à diviser automatiquement le fichier pour éviter que le fichier journal ne soit trop volumineux. Un exemple de configuration de journalisation est donné ci-dessous.

import logging.config
 
logging.config.dictConfig({
 'version': 1,
 'disable_existing_loggers': True,
 'formatters': {
  'verbose': {
   'format': "[%(asctime)s] %(levelname)s [%(name)s:%(lineno)s] %(message)s",
   'datefmt': "%Y-%m-%d %H:%M:%S"
  },
  'simple': {
   'format': '%(levelname)s %(message)s'
  },
 },
 'handlers': {
  'null': {
   'level': 'DEBUG',
   'class': 'logging.NullHandler',
  },
  'console': {
   'level': 'DEBUG',
   'class': 'logging.StreamHandler',
   'formatter': 'verbose'
  },
  'file': {
   'level': 'DEBUG',
   'class': 'logging.RotatingFileHandler',
   # 当达到10MB时分割日志
   'maxBytes': 1024 * 1024 * 10,
   # 最多保留50份文件
   'backupCount': 50,
   # If delay is true,
   # then file opening is deferred until the first call to emit().
   'delay': True,
   'filename': 'logs/mysite.log',
   'formatter': 'verbose'
  }
 },
 'loggers': {
  '': {
   'handlers': ['file'],
   'level': 'info',
  },
 }
})

Nous pouvons l'utiliser pour enregistrer des journaux dans un module

import logging
logger = logging.getLogger(__name__)
 
if __name__ == '__main__':
 logger.info('log info')

Utilisation dans un environnement multi-processus

Selon la documentation officielle, la journalisation est thread-safe, c'est-à-dire qu'il est sûr que plusieurs threads d'un processus écrivent des journaux dans le même fichier en même temps. temps de. Mais (oui, il y a un mais), il n'est pas sûr que plusieurs processus écrivent des journaux dans le même fichier. La déclaration officielle est la suivante :

Parce qu'il n'existe pas de moyen standard de sérialiser l'accès à un seul fichier sur plusieurs processus en Python. Si vous devez vous connecter à un seul fichier à partir de plusieurs processus, une façon de procéder est de le faire. pour que tous les processus se connectent à un SocketHandler et disposent d'un processus distinct qui implémente un serveur de socket qui lit à partir du socket et se connecte au fichier (si vous préférez, vous pouvez consacrer un thread dans l'un des processus existants pour exécuter cette fonction. .)

Certaines personnes diront, alors je n'ai pas besoin de plusieurs processus. Cependant, Python a un gros verrou GIL (vous pouvez lire ici les différends concernant GIL). Il est impossible d'utiliser le multi-threading pour tirer parti des processeurs multicœurs. Dans la plupart des cas, le multi-processus sera utilisé pour en tirer parti. des processeurs multicœurs, nous ne pouvons donc toujours pas contourner le problème de ne pas ouvrir les journaux sous plusieurs processus.

Afin de résoudre ce problème, vous pouvez utiliser ConcurrentLogHandler. ConcurrentLogHandler peut écrire en toute sécurité des journaux dans le même fichier dans un environnement multi-processus et peut diviser le fichier journal lorsque le fichier journal atteint une taille spécifique. Dans le module de journalisation par défaut, il existe une classe TimedRotatingFileHandler qui peut diviser les fichiers journaux par heure. Malheureusement, ConcurrentLogHandler ne prend pas en charge cette façon de diviser les fichiers journaux par heure.

Réviser la classe en handlers.

logging.config.dictConfig({
 ...
 'handlers': {
  'file': {
   'level': 'DEBUG',
   # 如果没有使用并发的日志处理类，在多实例的情况下日志会出现缺失
   'class': 'cloghandler.ConcurrentRotatingFileHandler',
   # 当达到10MB时分割日志
   'maxBytes': 1024 * 1024 * 10,
   # 最多保留50份文件
   'backupCount': 50,
   # If delay is true,
   # then file opening is deferred until the first call to emit().
   'delay': True,
   'filename': 'logs/mysite.log',
   'formatter': 'verbose'
  }
 },
 ...
})

Après l'exécution, vous pouvez constater qu'un fichier .lock sera automatiquement créé et que le fichier journal peut être écrit en toute sécurité via le verrou.

Pour des explications plus détaillées sur l'utilisation du module de journalisation en Python dans un environnement multi-processus, veuillez faire attention au site PHP chinois !