[ TAG 162 ][30.09.2021] -Erfolgreich -IAP-20210601-20210722-1145 -RPRCSL_LOGGER

Ich beginne meine Worksession um [30.09.2021][0850]. Heute habe ich einen Nachtrag für [T156] erledigt. In diesen Beitrag erwähnte ich sehr gute YouTube-Beiträge von mir unbekannten Entwickler.

Wie immer beginne ich mich in den letzten Entwicklungsstand einzuarbeiten.

Gestern habe bezüglich des Moduls einen Denkfehler gemacht. Ich ging davon aus, dass der Projekt-Name sich nicht verändert. Aber das Projekt kann sich ja beliebig nach jeder ALOG-Aufnahme ändern. Das ist ein sehr wichtiges Detail. Im Grunde bedeutet es, dass diese Informationen an den ALOG-Prozess gebunden sind. Somit sollten diese Daten in die RPRCSL-Liste eingebunden werden.

Dafür muss ich mich wieder in die alte Struktur des RPRCSL-Item einarbeiten. Im [T156] habe ich mich mit diesen Thema auseinander gesetzt.

RPRCSL-Item
-------------------------------------------------------------------------------
18400:{
'name':'python.exe',
'pid': 18400,
'ppid': 13316,
'status': 'running',
'create_time_0': 1632470761.568949,
'create_time_1': '2021-09-24 10:06:01',
'closed_time_0': None,
'closed_time_1': None
}
-------------------------------------------------------------------------------
Quelle: 
https://artem-kraft.blogspot.com/2021/09/tag-156-24092021-erfolgreich-iap.html
-------------------------------------------------------------------------------

Hier ist der neue Entwurf der RPRCSL-Liste:

Entwurf der neuen RPRCSL-Liste

30.09.2021

DOC:

E:\2021\Projekte\Python\2021\06_jun\IAP-20210601-20210722-1145\DOCS\

20210930-RPRCSL-ENTWURF.txt

-------------------------------------------------------------------------------

prfxitm:{

'prfx':'log'

'prfx_delimiter':'_'

}

sfxitm:{

'sfx':'rprcsl',

'sfx_delimiter':'.'

}

ssnitm:{

'ssn_delimiter':'-'

}

18400:{

'ssn_prj':'DEON'

'ssn_kw':'KW20'

'ssn_date':'20210509'

-----------------------------------------------

'subssn_hour':'12'

'subssn_min':'35'

'subssn_sec':'45'

-----------------------------------------------

logname: 'log_DEON-KW20-20210509_123545.rprcsl'

-----------------------------------------------

'name':'python.exe',

'pid': 18400,

'ppid': 13316,

'status': 'running',

'create_time_0': 1632470761.568949,

'create_time_1': '2021-09-24 10:06:01',

'closed_time_0': None,

'closed_time_1': None

}

Diese Überlegungen führen mich dazu, für jedes ALOG eine LOG-Datei anzulegen. Wenn man diesen Gedanken weiter geht, so muss ich dann auch die FileHandler des Loggers bei jeder ALOG-Anlegung und ALOG-Prozessausführung neu anlegen.

Es ist Technisch möglich. Ob es so sinnvoll ist, wird sich noch herausstellen. Aber erst einmal führe ich einige Quellen zu diesen Thema auf, die die Technische Umsetzung möglich machen.

• Quellen:
• [https://cppsecrets.com/users/9837115971039711411510410110897114494848484864103109971051084699111109/Python-logginggetLoggerremoveHandlerhandler.php]
• [https://docs.python.org/3/library/logging.html]
• [https://docs.python.org/3/library/logging.html#logging.Logger.addHandler]
• [https://docs.python.org/3/library/logging.html#logging.Logger.removeHandler]
• [https://docs.python.org/3/library/logging.html#logging.Logger.hasHandlers]
• [https://docs.python.org/3/library/logging.handlers.html]

import logging


def FILE():
    prfx = "log"
    prfx_delitimer = "_"
    sfx = "rprcsl"
    sfx_delimiter = "."
    ssn_prj = "DEON"
    ssn_kw = "KW20"
    ssn_date = "20210509"
    ssn_delimiter = "-"
    ssn_id = f"{ssn_prj}{ssn_delimiter}" \
             f"{ssn_kw}{ssn_delimiter}" \
             f"{ssn_date}"

    subssn_hour = 12
    subssn_min = 35
    subssn_sec = 45
    subssn_id = f"{subssn_hour}{subssn_min}{subssn_sec}"

    filename = f"{prfx}{prfx_delitimer}" \
               f"{ssn_id}{prfx_delitimer}" \
               f"{subssn_id}{sfx_delimiter}" \
               f"{sfx}"
    print("")
    print("")
    print(f"filename: {filename}")
    print("")
    return "test2.log"


def PATH():
    return "ALOG_20210722\\"


RPRCSL_LOGGER = logging.getLogger(__name__)
RPRCSL_LOGGER.setLevel(logging.DEBUG)

LGFT20210927 = "%(asctime)s :: %(levelname)s :: %(process)d :: %(name)s :: %(funcName)s :: %(lineno)d ::: %(message)s"
LGFRMTR20210927 = logging.Formatter(LGFT20210927)

LGFH20210927 = logging.FileHandler(f"{PATH()}{FILE()}")
LGFH20210927.setLevel(logging.DEBUG)
LGFH20210927.setFormatter(LGFRMTR20210927)

LGSH20210927 = logging.StreamHandler()
LGSH20210927.setLevel(logging.DEBUG)
LGSH20210927.setFormatter(LGFRMTR20210927)

RPRCSL_LOGGER.addHandler(LGFH20210927)
RPRCSL_LOGGER.addHandler(LGSH20210927)

print(f"LGFH20210927: {LGFH20210927}")
print(f"RPRCSL_LOGGER: {RPRCSL_LOGGER.handlers}")
RPRCSL_LOGGER.removeHandler(LGFH20210927)
print(f"RPRCSL_LOGGER: {RPRCSL_LOGGER.handlers}")

-------------

Ausgabe:

-------------

LGFH20210927: <FileHandler E:\2021\Projekte\Python\2021\06_jun\IAP-20210601-20210722-1145\ALOG_20210722\test2.log (DEBUG)>

RPRCSL_LOGGER: [<FileHandler E:\2021\Projekte\Python\2021\06_jun\IAP-20210601-20210722-1145\ALOG_20210722\test2.log (DEBUG)>, <StreamHandler <stderr> (DEBUG)>]

RPRCSL_LOGGER: [<StreamHandler <stderr> (DEBUG)>]

-------------

Ausgabe-Ende:

-------------

Der Entwicklungsstand des Logger-Moduls reicht den Anforderungen nicht aus und muss deshalb erweitert werden.

Die Logger-Struktur muss wesentlich komplexer ausgebaut werden.

Wir haben den FileHandler, der zu diesen Zeitpunkt nur das Log-File[test2.log] ausgibt.

Jeder ALOG-Prozess benötigt einen FileHandler. Der FileHandler muss mit dem Prozess-Start gestartet und auch beendet werden.

Andererseits wird der Logger jedes Mal neu angelegt, weil es sich um ein separaten Prozess handelt. Dieser Prozess besitzt seinen eigen Speicher. Dieser Umstand führt dazu, dass diese Zeile bei einen Prozess-Start für den gestarteten Prozess separat ausgeführt wird.

from ALOG_20210722.RPRCSL_LOGGER_20210929 import RPRCSL_LOGGER as rprcsl_log

Wir bekommen eine neue unabhängige Instanz [rprcsl_log].

Diese Überlegungen führen mich dazu, meine Position von Vorhin zu überdenken. Ich benötige eigentlich keine komplexe Struktur.

Wenn ich diese Zeile mir anschaue, so denke ich, ich könnte theoretisch die Zeitfunktionen in den [LOGGER]-Modul integrieren.

Weil diese Zeile für jeden Prozess separat ausgeführt wird, werden die Daten der Datum-Funktionen immer den Prozessstart abbilden.

Somit kann eigentlich das Problem der Logs, dass ich mir sehr kompliziert vorgestellt habe, sehr leicht gelöst werden.

Ich finde jedoch trotzdem, dass ich das Modul [RPRCSL_LOGGER_20210929.py] überarbeiten müsste. Zusätzlich muss ich auch die Verwendung und den Import des Moduls in anderen Modulen umgestalten.

Wie werde ich das Umsetzen? Ich werde das Modul über Methoden steuern. Methoden, die den Logger initialisieren. Methoden, die die dazugehörigen Handler initialisieren. Somit wird das Modul initialisiert jedoch werden die Logger-System relevanten Komponente nicht ausgeführt. Sie werden nur an bestimmten Stellen des Moduls ausgeführt.

Weil die Umstände bei mir mit den Prozessen so aussehen, wird das Modul[RPRCSL_LOGGER_20210929.py] auch für diese Umstände designt. Aus meiner jetzigen Perspektive eignet sich das Modul nicht für Threads, sondern nur für separate Prozesse. Die Begründung für diese Schlussfolgerung liegt im Speicher-Management von Prozessen. Jeder Prozess hat seine eigene Speicherbereiche im CPU-Cache und somit wird die Instanz des Logger immer wieder bei jeden Prozess-Start neu ausgeführt. Diese Umstände machen die Handler-Verwaltung unbrauchbar.

Jeder Prozess wird genau nur einen ALOG zugeführt. Ein gestarteter Prozess repräsentiert genau einen ALOG. Für diesen Prozess bzw. ALOG gibt es eine Log-Datei. In dieser Log-Datei wird der Prozess dokumentiert.

Meine nächste Aufgabe wird darin bestehen, die [RPRCSL_LOGGER_20210929.py] zu überarbeiten.

Hochachtungsvoll

Artem Kraft