Detaillierte Erläuterung der Verwendung des Protokollierungsmoduls in Python in einer Multiprozessumgebung

Viele Anwendungen verfügen über ein Protokollmodul, das zur Aufzeichnung einiger wichtiger Informationen während des Betriebs des Systems verwendet wird, um die Verfolgung des Betriebsstatus des Systems zu erleichtern. In diesem Artikel wird hauptsächlich die Verwendung des Protokollierungsmoduls in einer Umgebung mit mehreren Prozessen vorgestellt. Lassen Sie uns gemeinsam einen Blick darauf werfen.

Vorwort

Ich glaube, jeder Programmierer sollte wissen, dass es bei der Verwendung von Python zum Schreiben von Hintergrundaufgaben häufig erforderlich ist, Ausgabeprotokolle zu verwenden, um den Status der Programmausführung aufzuzeichnen und Fehler zu melden, wenn Fehler auftreten Die Details werden zur weiteren Fehlerbehebung und Analyse gespeichert. Das Protokollierungsmodul von Python ist in dieser Situation ein großer Helfer.

Das Protokollierungsmodul kann die Protokollebene DEBUG, INFO, WARNUNG, FEHLER und KRITISCH angeben. Beispielsweise können während der Entwicklung und beim Debuggen Protokolle mit Ebenen über DEBUG ausgegeben werden, während in einer Produktionsumgebung nur INFO ausgegeben werden ausgegeben werden kann. (Wenn nicht angegeben, ist die Standardstufe Warnung)

Protokollierung Sie können auch die Ausgabe an die Befehlszeile oder Datei angeben und die Protokolldatei auch nach Zeit oder Größe aufteilen.

Auf die detaillierte Verwendung der Protokollierung werde ich hier nicht näher eingehen. Sie können sich hier auf die offizielle Dokumentation oder die Einführung beziehen.

Protokollierungskonfiguration

Normalerweise müssen wir das Protokoll in einer Datei speichern und erwarten, dass die Datei automatisch aufgeteilt wird, um zu vermeiden, dass die Protokolldatei zu groß wird. Nachfolgend finden Sie ein Beispiel für die Protokollierungskonfiguration.

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',
  },
 }
})

Wir können damit Protokolle in einem Modul aufzeichnen

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

Verwendung in einer Umgebung mit mehreren Prozessen

Laut offizieller Dokumentation ist die Protokollierung threadsicher, das heißt, es ist für mehrere Threads in einem Prozess sicher, gleichzeitig Protokolle in dieselbe Datei zu schreiben Zeit von. Aber (ja, es gibt ein Aber) es ist nicht sicher, dass mehrere Prozesse Protokolle in dieselbe Datei schreiben. Die offizielle Aussage lautet:

Da es in Python keine Standardmethode gibt, um den Zugriff auf eine einzelne Datei über mehrere Prozesse hinweg zu serialisieren. Wenn Sie sich von mehreren Prozessen aus in einer einzelnen Datei anmelden müssen, ist dies eine Möglichkeit alle Prozesse in einem SocketHandler protokollieren zu lassen und über einen separaten Prozess zu verfügen, der einen Socket-Server implementiert, der aus dem Socket liest und in einer Datei protokolliert (Wenn Sie möchten, können Sie einen Thread in einem der vorhandenen Prozesse für die Ausführung dieser Funktion reservieren .)

Manche werden sagen, dann brauche ich nicht mehrere Prozesse. Allerdings verfügt Python über eine große GIL-Sperre (über die Streitigkeiten über GIL können Sie hier lesen). Es ist unmöglich, Multi-Threading zu verwenden, um die Vorteile von Multi-Core-CPUs zu nutzen von Multi-Core-CPUs, daher können wir das Problem, dass Protokolle unter mehreren Prozessen nicht geöffnet werden, immer noch nicht umgehen.

Um dieses Problem zu lösen, können Sie ConcurrentLogHandler verwenden, um Protokolle in einer Umgebung mit mehreren Prozessen sicher in dieselbe Datei zu schreiben und die Protokolldatei aufzuteilen, wenn die Protokolldatei eine bestimmte Größe erreicht. Im Standardprotokollierungsmodul gibt es eine TimedRotatingFileHandler-Klasse, die Protokolldateien nach Zeit aufteilen kann. Leider unterstützt ConcurrentLogHandler diese Art der Aufteilung von Protokolldateien nach Zeit nicht.

Überarbeiten Sie die Klasse in Handlern.

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'
  }
 },
 ...
})

Nach dem Ausführen können Sie feststellen, dass automatisch eine .lock-Datei erstellt wird und die Protokolldatei sicher durch die Sperre geschrieben werden kann.

Ausführlichere Erläuterungen zur Verwendung des Protokollierungsmoduls in Python in einer Multiprozessumgebung finden Sie auf der chinesischen PHP-Website!