logging — händelseloggning

Denna modul tillhandahåller en lättviktig delmängd av standardpaketet logging i Python anpassad för MicroPython. Den stöder nivåbaserad loggning genom hierarkiskt namngivna Logger-objekt, en liten uppsättning hanterare (StreamHandler, FileHandler), printf-liknande formatering via Formatter samt bekvämlighetsfunktioner på modulnivå motsvarande dem som arbetar mot rotloggaren.

Modulen följer det välbekanta CPython-API:et tillräckligt nära för att enkla applikationer skrivna för standardbiblioteket ska fungera oförändrade. Filter, låsning mellan flera processer, formatet för konfigurationsfiler och de flesta hanterarklasser tillhandahålls inte.

Nivåkonstanter

logging.CRITICAL: int

Numeriskt värde 50. Används för oåterkalleliga fel.

logging.ERROR: int

Numeriskt värde 40. Används för allvarliga problem.

logging.WARNING: int

Numeriskt värde 30. Standardnivå för en nyligen konfigurerad rotloggare.

logging.INFO: int

Numeriskt värde 20. Används för bekräftelsemeddelanden.

logging.DEBUG: int

Numeriskt värde 10. Används för finkornig diagnostikutmatning.

logging.NOTSET: int

Numeriskt värde 0. Anger en loggare utan konfigurerad nivå (den effektiva nivån ärvs då från rotloggaren eller WARNING).

Funktioner

logging.getLogger(name: str | None = None) → Logger

Returnerar den Logger som är registrerad under name och skapar den vid första användningen. Om name är None returneras rotloggaren. Det första anropet med name="root" (eller med name osatt) anropar implicit basicConfig för att koppla på en standard-StreamHandler som skriver till sys.stderr.

logging.log(level: int, msg: str, *args) → None

Loggar ett meddelande på nivån level på rotloggaren. args interpoleras in i msg med printf-liknande %-formatering; ett enskilt dict-argument används som mappning.

logging.debug(msg: str, *args) → None

Motsvarar getLogger().debug(msg, *args).

logging.info(msg: str, *args) → None

Motsvarar getLogger().info(msg, *args).

logging.warning(msg: str, *args) → None

Motsvarar getLogger().warning(msg, *args).

logging.error(msg: str, *args) → None

Motsvarar getLogger().error(msg, *args).

logging.critical(msg: str, *args) → None

Motsvarar getLogger().critical(msg, *args).

logging.exception(msg: str, *args, exc_info: bool | BaseException = True) → None

Motsvarar getLogger().exception(msg, *args, exc_info=exc_info). Loggar meddelandet på ERROR och formaterar dessutom den aktiva undantagets stackspårning när exc_info är sann. Om exc_info självt är ett BaseException används det undantagets stackspårning; annars konsulteras sys.exc_info() när det är tillgängligt.

logging.shutdown() → None

Stänger varje hanterare som är kopplad till varje känd loggare och glömmer loggarna. Registreras automatiskt via sys.atexit när den kroken är tillgänglig.

logging.addLevelName(level: int, name: str) → None

Kopplar det textuella name till den numeriska nivån level så att Formatter kan återge det via %(levelname)s.

logging.basicConfig(filename: str | None = None, filemode: str = 'a', format: str | None = None, datefmt: str | None = None, level: int = WARNING, stream=None, encoding: str = 'UTF-8', force: bool = False) → None

Konfigurerar rotloggaren med en enda hanterare.

Om filename anges skapas en FileHandler med filemode och encoding; annars används en StreamHandler som skriver till stream (med sys.stderr som standard).

format och datefmt skickas vidare till en ny Formatter.

level anger både hanterarens nivå och rotloggarens nivå.

Om rotloggaren redan har hanterare är denna funktion verkningslös såvida inte force är True, i vilket fall de befintliga hanterarna stängs och ersätts.

Klasser

class logging.Logger(name: str, level: int = NOTSET)

En namngiven loggare. Skapa loggare via getLogger snarare än direkt, så att getLogger kan returnera samma instans för samma namn.

name: str

Loggarens punktnotationsnamn.

level: int

Den konfigurerade numeriska nivån. 0 (NOTSET) betyder ”ärv”.

handlers: list

Listan över Handler-instanser som är kopplade till denna loggare. När den är tom skickas meddelanden till rotloggarens hanterare.

setLevel(level: int) → None

Anger loggarens tröskelnivå.

isEnabledFor(level: int) → bool

Returnerar True om ett meddelande på nivån level skulle behandlas av denna loggare.

getEffectiveLevel() → int

Returnerar den första nollskilda av: denna loggares nivå, rotloggarens nivå eller WARNING.

log(level: int, msg: str, *args) → None

Loggar msg på nivån level. args interpoleras in i msg med %-operatorn; om det första positionsargumentet är en dict används det som en mappning.

debug(msg: str, *args) → None

Loggar msg på DEBUG.

info(msg: str, *args) → None

Loggar msg på INFO.

warning(msg: str, *args) → None

Loggar msg på WARNING.

error(msg: str, *args) → None

Loggar msg på ERROR.

critical(msg: str, *args) → None

Loggar msg på CRITICAL.

exception(msg: str, *args, exc_info: bool | BaseException = True) → None

Loggar msg på ERROR och, när exc_info är sann, lägger till den formaterade stackspårningen. Om exc_info är en BaseException-instans återges det undantagets stackspårning; annars konsulteras det aktiva undantaget via sys.exc_info().

addHandler(handler: Handler) → None

Kopplar handler till denna loggare.

hasHandlers() → bool

Returnerar True om några hanterare är kopplade till denna loggare.

class logging.Handler(level: int = NOTSET)

Basklass för alla hanterare. Underklasser implementerar emit().

level: int

Hanterarens tröskelnivå.

formatter: 'Formatter | None'

Den aktiva Formatter, eller None.

setLevel(level: int) → None

Anger hanterarens tröskelnivå.

setFormatter(formatter: Formatter) → None

Kopplar formatter till denna hanterare.

format(record: LogRecord) → str

Återger record med den konfigurerade formateraren.

close() → None

Frigör resurser som hålls av hanteraren. Anropas av shutdown och av FileHandler när den stängs.

class logging.StreamHandler(stream=None)

Hanterare som skriver formaterade poster, följt av self.terminator ("\n" som standard), till stream. stream är som standard sys.stderr.

stream

Målströmobjektet.

terminator: str

Sträng som läggs till efter varje formaterad post. Är som standard "\n".

emit(record: LogRecord) → None

Skriver record till stream om dess nivå når upp till hanterarens tröskel.

close() → None

Tömmer den underliggande strömmen när den exponerar en flush-metod.

class logging.FileHandler(filename: str, mode: str = 'a', encoding: str = 'UTF-8')

Underklass till StreamHandler som öppnar filename med angivet mode och encoding och skriver formaterade poster till den. Den underliggande filen stängs vid close().

class logging.Formatter(fmt: str | None = None, datefmt: str | None = None)

Återger LogRecord-instanser till strängar.

fmt är en printf-liknande mall. Igenkända nycklar är %(name)s, %(message)s, %(msecs)d, %(asctime)s och %(levelname)s. När den är osatt är den som standard "%(levelname)s:%(name)s:%(message)s".

datefmt är den time.strftime-mall som används för att återge %(asctime)s. Är som standard "%Y-%m-%d %H:%M:%S".

usesTime() → bool

Returnerar True om formatmallen refererar till asctime.

formatTime(datefmt: str, record: LogRecord) → str | None

Formaterar record.ct med time.strftime och datefmt. Returnerar None på plattformar där time.strftime inte är tillgängligt.

format(record: LogRecord) → str

Återger record. Om mallen använder asctime anropas formatTime() först för att fylla i record.asctime.

class logging.LogRecord

Behållare för de data som skickas från en Logger till dess hanterare. Instanser fylls i via set(); loggarimplementationer återanvänder en enda post per loggare för att minska minnesallokeringar.

name: str

Den ursprungliga loggarens namn.

levelno: int

Numerisk nivå för denna post.

levelname: str

Textuellt nivånamn.

message: str

Det fullständigt formaterade loggmeddelandet.

ct: float

Skapelsetidpunkt enligt vad time.time() returnerar.

msecs: int

Millisekundkomponenten av ct.

asctime: str | None

Människoläsbar tidsstämpel; fylls i lat av Formatter.

set(name: str, level: int, message: str) → None

Initierar posten med de angivna värdena och fångar den aktuella tiden.