Python Syslog -logging

Python -funksjonen til “Syslog -logging” kan få hver systemlogger til å motta en seriell melding fra denne funksjonen. Når programvaren er i løpeposisjon, holder loggeren oppmerksom på å fungere. Her er det alternative vektleggingsargumentet i syslog som tilsvarer logginformasjon om sett som hovedprioritet. I hovedsak kan vi si at Syslog -logging i Python lar nettverkskomponentene koble seg til en loggingsvert ved hjelp av et felles meldingsformat. Den ble utviklet og opprettet først og fremst for å tillate overvåkningsnettverksenheter.

Et syslog -grensesnitt kan brukes av systemene for å overføre varslingsmeldingene under en rekke forskjellige omstendigheter. Den faktiske metoden for å overvåke handlingene som er tatt av programvare for opprettelse, drift og diagnose av programvarelogging er avgjørende. Det er relativt få odds for at vi vil finne kilden til problemet hvis programvaren vår mislykkes og vi ikke opprettholder tilstrekkelige loggingsposter. Enkelte programmerere bruker ideen om å publisere setningene for å sjekke om de ble implementert separat, eller om en feil har skjedd. Imidlertid er ikke utskrift et smart trekk. For grunnleggende skript kan det være svaret på problemene våre. Imidlertid vil utskriftsløsningen komme til kort for komplekse programmer.

Hvordan implementere syslog -logging i Python

Et etablert Python -programmeringsspråk har en pakke som heter Logging som muliggjør publisering av statusmeldingsoppdateringene til filer eller andre utgangsstrømmer. Posten kan gi detaljene om hvilken del av programmet som kjøres og problemene som dukker opp. La oss begynne å implementere Python -koden for Syslog -logging der vi tar et eksempel for å forklare den på en bedre måte. Koden vår for Python starter med å importere noen biblioteker der vi først importerer "logging" -biblioteket siden vi utfører loggingsfenomenet i artikkelen vår.

Etter det importerer vi “loggingen.Håndterere ”bibliotek for alle tilfeller som kan forårsake noen feil, slik at det kan håndtere og ordne opp eventuelle unntakstilfeller for feil. Det tredje biblioteket som vi importerer er “Sysloghandler” fra familien til “Logging.håndterere ”for å lage loggingsinteraksjonen med operativsystemet vårt.

I det siste biblioteket importerer vi "Formatter" fra "Logging" -familien til Pythons interaktive fil. Etter alle bibliotekene definerer vi nå en ny funksjon av navnet "Sysmain" som kan kalles hovedfunksjonen til programkoden. Nå oppretter vi en minnefordeling av navnet “SYS_LOGGER” og tildeler funksjonen til “Logging.getLogger () ”-funksjon og gi den uttalelsen om“ Beste logger ”. Etter det bruker vi “sys_logger.SetLevel (logging.Debug) ”for å sette opp nivået for at systemet skal samhandle med loggfeilen som oppstår under loggprosessen for å håndtere det.

På dette trinnet oppretter vi nå "SYS_Handler" og tildeler det som en "SyslogHhandler ()" -funksjon. Deretter gir vi banen til systemet vårt sammen med noen interaktive filer som er relatert til pålogging.

Etter at vi har tilordnet systemadresseveien for “Syslog Logging”, bruker vi “SYS_LOGGER.addHandler () "-funksjon og ring" sys_handler "-funksjonen innen" sys_logger.addHandler () ”-funksjon. Vi oppretter en ny funksjon og navngir den som "logging_format ()" og tildeler loggmeldingen og filnavnet sammen med nivånavnet. Nå tar vi “SYS_Handler.setFormatter () ”-funksjon og gi" logging_format "til formaterfunksjonen.

For den siste funksjonen bruker vi “sys_logger.Debug () ”og gi det som verdien som en uttalelse om“ My Python!!”. Deretter avslutter vi hovedfunksjonen ved å bruke “IF” -klausulen og returnere hovedfunksjonen i den siste “Sysmain ()” for å gjennomgå loggprosessen.

Koden for "syslog -logging" er gitt i følgende i tekstform for de andre brukerne å implementere den av seg selv:

Kode:

Importlogging
Importlogging.håndterere
fra logging.Håndterere importerer Sysloghandler
Fra å logge importformater
def sysmain ():
Sys_logger = logging.getLogger ('beste logger')
Sys_logger.SetLevel (logging.Debug)
Sys_handler = syslogHhandler (anlegg = sysloghandler.Log_daemon,
adresse = '/brukere/aqsayasin')
Sys_logger.AddHandler (SYS_Handler)
logging_format = '[%(nivånavn) s]%(filnavn) s:%(funcname) s:%(lin) d \
"%(melding) s" '
SYS_HANDLER.setFormatter (formatter (fmt = logging_format))
Sys_logger.Debug ('My Python!!')
if __name__ == '__main__':
Sysmain ()

Etter å ha fullført kodearbeidet, ser vi på loggingen av systemet som viser dagens dato for “Nov” som måneden, “21” som dato, og “01:05:12” som tidspunktet for operativsystemet vårt. Vårt brukernavn, “Aqsayasin”, er også utstyrt med Python -detalj på “9851” og feilsøker detaljene langs “Syslog” på hovedfunksjonen med vår uttalelse trykt på Syslog som er “My Python!!”.

Den første linjen i dette programmet er lik den vi kjører tidligere i Python Code. Den eksporterer formateringen sammen med “Logging”, “Håndterere” og “Sysloghandler” -biblioteker. Nå legger vi til den lignende "Sysloghandler" som vi la til tidligere i koden i en "Main ()" -funksjon etter å ha opprettet en logger og satt standardnivået til "Debug". Vi skriver deretter en formater og inkluderer den med loggeren. Vi kan se hvordan den delen av de samlede bedriftsfunksjonene ved å kontrastere denne varslingen med formateringsteksten. Strengen viser "nivånavnet", "filnavn", "funcname", "lineno" og "melding" i skjermloggen:

Meldingen vises som vår oppgitte uttalelse viser i “SYSLOG.py ”hovedfunksjon,“ My Python!!”, Sammen med" Sysmain () "-funksjonen.

Til slutt har vi "nivånavnet" som utjevnet til "feilsøkingen" på loggsystemet. Vi kan se banen, funksjonsnavnet og linjenummeret i de gjenværende delene av meldingen som lar oss forstå nøyaktig hvor loggmeldingen er oppstått. Meldingsnivået er indikert i begynnelsen av noe som brevet med firkantede parenteser. "[Debug]" for det tekstlige uttrykket til et hogstmeldingsnivå erstattes med "[%(nivånavn) s]".

La oss nå prøve å implementere et annet eksempel for Python -emnet "Syslog Logging" ved å importere tre biblioteker som vi brukte i de forrige eksemplene som er "logging", "logging.Handler ”, og“ Sys ”. Etter å ha fått disse tre bibliotekene, oppretter vi en funksjon av "sys_logger" og tildeler "logging.getLogger () ”-funksjon. Den andre funksjonen til “SYS_LOGGER.setLevel () ”-funksjonen gir" logging.Info ”kommando i den.

Deretter tildeler vi loggadressen til vår lokale vertsadresse som er "9238" til den nye funksjonen som er opprettet som er "syslogging". Vi kaller deretter “sys_logger.AddHandler () ”-funksjon for unntakshåndtering av tilfeller som oppstår i" syslogging ". Til slutt bruker vi "print ()" -funksjonen for å vise funksjonsloggingsresultatet og avkall "sys_logger.Handler ”-funksjon innen“ print () ”-funksjonen.

Det andre eksemplet på "syslog -logging" som vi implementerte i Python er gitt i det følgende i tekstform:

Kode:

Importlogging
Importlogging.håndterere
Importer Sys
Sys_logger = logging.getLogger ()
Sys_logger.SetLevel (logging.Info)
syslogging = logging.håndterere.SyslogHhandler (adresse = ("localhost", 9238)))
Sys_logger.AddHandler (syslogging)
Print (SYS_LOGGER.håndterere)

Når koden er fullført, kommer den tilbake med en utdanningsmelding når programmet avslutter uttalelsen for å logge av løpsprogrammet. Hvis koden stopper og vi vil fortsette den, kan vi starte en annen systemlogg. Hvis vi ønsker å avslutte konsollapplikasjonen, trykker vi på "Enter" -knappen og systemlogger av gjeldende applikasjonskonsoll.

Konklusjon

I denne artikkelen diskuterte vi temaet "Syslog -logging" av Python -språket ved å implementere kodeeksemplene og nødvendige viktige forklaringer. Vi holdt to viktige eksempler for dette emnet etter det beste av vår kunnskap. Det første eksemplet gjorde noen feilsøkingshåndtering for systemloggen som er gitt sammen med detaljene i funksjonsnavnet og brukerveien. Mens det andre eksemplene brukte konseptet konsollfilen som forlater fenomenet og trykker på "Enter" -knappen for å logge systemloggingen.