Django Logging

Wszyscy programiści debugują błędy. Rozwiązywanie tych błędów wymaga czasu. W większości przypadków pomaga wiedzieć, kiedy i gdzie wystąpił błąd. Powiedziałbym, że komunikaty o błędach Pythona są całkiem pomocne. Ale nawet te komunikaty okazują się bezużyteczne, gdy mowa o projektach z wieloma plikami. Ten problem i wiele innych korzyści wynika z logowania.

Jako programiści Django, ważne jest, abyśmy również opanowali logowanie. Technologie backendowe mają różne świetne narzędzia do implementacji logowania. Django również zapewnia wsparcie dla różnych frameworków i modułów logowania. My zaimplementujemy to używając podstawowego i jednego z popularnych, modułu logowania.

W tym tutorialu, nauczymy się o logowaniu. Zawartość będzie następująca:

• Co to jest logowanie?
• Moduł logowania Pythona
• Logowanie w Django

Gotowi do nauki. Zacznijmy.

Co to jest logowanie?

Logowanie jest techniką lub medium, które pozwala nam śledzić pewne zdarzenia w trakcie działania oprogramowania. Jest to ważna technika dla programistów. Pomaga im śledzić zdarzenia. Rejestrowanie jest dla nich jak dodatkowy zestaw oczu. Programiści są odpowiedzialni nie tylko za tworzenie oprogramowania, ale także za jego utrzymanie. Logowanie bardzo pomaga w tej części konserwacji.

Śledzi każde zdarzenie, które występuje przez cały czas. Oznacza to, że zamiast długiego śledzenia otrzymasz znacznie więcej. Tym razem, gdy wystąpi błąd, można zobaczyć, w którym system był. Ta metoda pomoże Ci szybko rozwiązać błędy. Ponieważ będziesz w stanie powiedzieć, gdzie wystąpił błąd.

Jak to działa? Co za tym stoi?

Logowanie jest obsługiwane przez oddzielny program. Ten program rejestrujący jest po prostu maszyną do pisania plików. Mówi się, że logger rejestruje pewne zdarzenia w formacie tekstowym. Zarejestrowane informacje są następnie zapisywane w plikach. Pliki do tego celu nazywane są logami. Logi są prostymi plikami zapisanymi z rozszerzeniem log. Zawierają one logi zaistniałych zdarzeń.

Cóż, jest to tylko jedna z najczęściej używanych implementacji, jak widać. Ponieważ my tylko przechowujemy informacje, możesz wymyślić więcej sposobów radzenia sobie z nimi.

Okay, jest dla nas jasne, że logowanie jest ważne. Czy jest to trudne? Nie, absolutnie nie kolego. Logowanie nie jest wcale trudne. Każdy, kto wie co nieco o konfiguracji, może tego użyć.

Będąc programistą Pythona, dostajesz tutaj również dodatkowe funkcje. Mamy cały moduł, który pozwala nam osiągnąć właśnie to. Jeśli chodzi o inne języki, istnieje wiele modułów, Java ma Log4j, a JavaScript ma swój własny loglevel. Wszystko to są niesamowite narzędzia, jak również. Ok, więc będziemy się tutaj zajmować Pythonem (mój ulubiony język).

Moduł logowania w Pythonie

Moduł logowania jest wbudowanym modułem Pythona. Jest on preinstalowany z Pythonem 3. Moduł logowania jest używany do śledzenia zdarzeń, które występują podczas działania programu. To może być rozszerzone na dowolną liczbę programów i dlatego dla oprogramowania jest łatwy do skonfigurowania i użycia.

Dlaczego używać modułu logowania?

Jako programista, możemy zapytać, dlaczego używać modułu logowania. Wszystko co robi logowanie to zapisywanie do pliku lub drukowanie na konsoli. Wszystko to można osiągnąć za pomocą instrukcji print. Więc jakie jest zapotrzebowanie na moduł logowania? To jest ważne pytanie. Odpowiedź na nie brzmi: logowanie jest modułem, który daje to, czego nie może dać print.

Używamy funkcji print, aby wypisać coś na konsolę. Tak więc, kiedy funkcja występuje, możemy uzyskać deklarację print, że funkcja została wykonana. Chociaż takie podejście sprawdza się w przypadku mniejszych aplikacji, jest ono nieefektywne.

Funkcja print staje się częścią twojego programu i jeśli program przestanie działać, nie otrzymasz wyniku. Ponadto, jeśli coś się stanie i system się zrestartuje, konsola również będzie czysta. Więc, co wtedy zrobisz? Odpowiedzią na to jest moduł logowania.

Moduł logowania jest zdolny do:

• Wykonywania wielowątkowego
• Kategoryzowania wiadomości poprzez różne poziomy dziennika
• Jest o wiele bardziej elastyczny i konfigurowalny
• Daje bardziej uporządkowane informacje

Więc, są 4 główne części modułu logowania. Przyjrzymy się im jeden po drugim.

1. Loggery

Loggery są obiektami, z którymi programiści mają do czynienia. Można je rozumieć jako funkcje, które będą wywoływane w momencie ich wywołania. Loggerów używamy w naszych plikach projektowych. Dzięki temu, gdy funkcja zostanie wywołana, otrzymujemy szczegółowy raport. Logger może generować wiele poziomów odpowiedzi. Możemy go w pełni dostosować do swoich potrzeb.

2. Handlerzy

Handlery są obiektami, które emitują informacje. Pomyśl o nich jak o uchwytach do gazet. Ich głównym zadaniem jest przekazywanie informacji. Można to osiągnąć poprzez zapisanie informacji w pliku logu (domyślne zachowanie). Istnieją różne handlery dostarczane przez moduł logowania.

Możemy łatwo skonfigurować wiele handlerów dla tego samego loggera. Istnieją również handlerzy SMTP, które będą wysyłać rekordy dziennika do Ciebie. Handlerzy zazwyczaj zawierają logikę biznesową do logowania informacji.

3. Formatery

Formatery są tymi, które formatują dane. Widzisz, że handlerzy nie mogą wysyłać informacji, ponieważ jest to typ danych Pythona. Zanim będzie można je wysłać do kogokolwiek, muszą zostać przekonwertowane.

Dzienniki są domyślnie w formacie Log Records. Jest to klasa predefiniowana przez framework logowania. Daje ona różne metody do wykorzystania przez programistów. Ten format nie może być bezpośrednio wysłany przez sieć lub zapisany w pliku tekstowym. Aby go przekonwertować lub sformatować, potrzebujemy formaterów. Istnieją różne formatery dla różnych handlerów.

Domyślnie, formatery będą konwertować zapis logu na String. To zachowanie może być łatwo zmienione i możesz dostosować je jak chcesz. Ten format może być oparty na logice biznesowej, którą piszemy w Handlerach.

4. Filtry

Ostatnim elementem modułu logowania są filtry. Filtry, jak sama nazwa wskazuje, filtrują komunikaty. Nie każda wiadomość, którą przekazujemy musi być przechowywana lub transportowana. Albo mogą być różne handlery dla różnych wiadomości. Wszystko to jest osiągalne za pomocą filtrów.

Filtrów możemy używać zarówno z loggerami, jak i handlerami.

Dobrze, więc teraz mamy już podstawowe pojęcie o module logowania. Zapewnia on nam również poziomy komunikatów. Poziomy komunikatów są zdefiniowane jako:

DEBUG: Jest to dokładna informacja systemowa, gdy wszystko działa dobrze. Powie ci więcej dokładnych szczegółów na temat stanu systemu. Jego punkt ciężkości jest 10.

INFO: info będzie produkować mniej verbose informacje systemowe, ale jest podobny do debug. Ogólnie rzecz biorąc, mówi o tym, co system jest wykonywany. Jego punkt ciężkości to 20.

Ostrzeżenie: Zawiera informacje dotyczące problemów niskiego poziomu. Problemy te można zignorować, ponieważ nie powodują one zatrzymania systemu. Zaleca się jednak, aby problemy te zostały rozwiązane.

Punkt ciężkości wynosi 30.

BŁĄD: Ten komunikat jest poważny. Błąd będzie zawierał informacje o poważnym problemie, który wystąpił. Problem mógł zatrzymać działanie programu i wymaga natychmiastowej uwagi.

Its severity point is 40.

CRITICAL: Najbardziej krytyczny komunikat. Ten komunikat jest emitowany, gdy problem spowodował zatrzymanie systemu. Oznacza to, że cała aplikacja zatrzymała się z powodu tego problemu.

Punkt ciężkości wynosi 50.

Punkt ciężkości określa, jaki priorytet powinien zostać nadany. Załóżmy, że ustawiliśmy poziom dziennika na 30. Wtedy logger będzie zapisywał lub przechowywał informacje, gdy poziom będzie większy lub równy 30. Tak więc, musisz tylko potwierdzić, jaki poziom logowania chcesz uzyskać. Dowiemy się o nich więcej w dalszej części rozdziału.

Możemy łatwo zaimplementować logowanie poprzez zaimportowanie modułu. Ponieważ jest to moduł wbudowany, nie musimy go instalować przez pip.

Po prostu napisz to w swoim pliku Pythona i możemy używać loggerów.

Kod:

import logginglogging.warning("DataFlair Logging Tutorials")

Wyjście wygenerowane przez ten kod znajduje się poniżej. Jak widać, log jest drukowany na konsoli, posiada log-level, logger-name i message. root jest domyślną nazwą loggera. Będziemy używać tego typu funkcji z naszymi widokami w Django.

Poznaj kompletny tutorial na temat modułu logowania Pythona

Logowanie w Django

Django zapewnia logowanie poprzez użycie modułu logowania Pythona. Moduł logowania może być łatwo skonfigurowany.

Gdy chcemy użyć logowania w Django, musimy wykonać pewne kroki. Procedura będzie następująca:

1. Skonfigurujemy nasz plik settings.py dla różnych loggerów, handlerów, filtrów.
2. Zawrzemy kod loggerów w widokach lub innych modułach Django, gdzie będzie to konieczne.

Dobra, więc zaczynajmy.

Utwórz nowy projekt

Utworzymy nowy projekt dla logowania. Możesz następnie użyć logowania w istniejących projektach. Tak więc, aby utworzyć nowy projekt, wykonaj to polecenie w linii poleceń:

$ django-admin startproject dataflairlogs

To rozpocznie nowy projekt. Teraz skonfigurujemy plik settings.py tego projektu.

Konfigurowanie ustawień

Aby włączyć logowanie w Django, musimy skonfigurować jego ustawienia. Jest to całkiem proste. Przez konfigurowanie ustawień logowania rozumiemy zdefiniowanie:

• Loggerów
• Handlerów
• Filtrów
• Formaterów

Ponieważ Django pracuje z różnymi modułami, używamy metody dictConfig.

Są też inne surowe metody, ale dictConfig jest domyślnym zachowaniem Django.

Po prostu skopiuj ten kod w swoim settings.py

Kod:

# DataFlair #Logging InformationLOGGING = { 'version': 1, # Version of logging 'disable_existing_loggers': False, #disable logging # Handlers ############################################################# 'handlers': { 'file': { 'level': 'DEBUG', 'class': 'logging.FileHandler', 'filename': 'dataflair-debug.log', },######################################################################## 'console': { 'class': 'logging.StreamHandler', }, }, # Loggers #################################################################### 'loggers': { 'django': { 'handlers': , 'level': 'DEBUG', 'propagate': True, 'level': os.getenv('DJANGO_LOG_LEVEL', 'DEBUG') }, },}

Zrozumienie kodu:

Wiem, że kod jest trochę duży, ale jest bardzo łatwy do ogarnięcia. Dostajemy od Django wbudowaną zmienną LOGGING. Domyślne wartości logowania pochodzą właśnie z tego słownika. Ponieważ konfigurujemy ustawienia za pomocą słownika, nazywamy to metodą dictConfig. Wewnątrz słownika LOGGING znajduje się kilka ważnych kluczy.

1. version
2. disable_existing_loggers
3. handlers
4. loggers

Omówmy je po kolei. Klucz version mówi o wersji schematu. Ważne jest, aby miał on wartość. Domyślnie jest to 1.

Kolejnym kluczem jest disable_existing_loggers. Ten klucz mówi Django, aby nie wyłączał loggerów. Domyślnie, Django używa niektórych własnych loggerów. Te loggery są połączone z Django ORM i innymi wewnętrznymi częściami Django. Ten klucz ma domyślnie wartość True. Tak więc, wyłączy on te rejestratory.

Są różne zapytania do bazy danych i wywołania funkcji, które rejestrują rejestratory. Dlatego zalecane jest, aby nie True ten klucz.

Handlers jest 3 kluczem. Jak już mówiliśmy, handlerzy obsługują komunikaty i przekazują je do konsoli, pliku, itp. Same handlery są słownikiem. Nazwy kluczy w słowniku będą nazwami handlerów. Istnieją różne handler’y dostarczane przez moduł logowania. My używamy tutaj dwóch handlerów.

1. FileHandler: logger-name – filehandler

FileHandler będzie przechowywał logi w pliku. Jak widzisz, nadaliśmy nazwę pliku jako dataflair-debug.log.

The level definiuje, do jakiego poziomu logger ma zapisywać logi.

Uwaga:

Pliki logów są zazwyczaj przechowywane z rozszerzeniem .log. Ten plik może być edytowany tylko z uprawnieniami. Może być tylko dołączany.

2. StreamHandler: nazwa loggera – console

Ręcznik strumienia będzie przesyłał strumień dziennika na konsolę. To nie jest zalecana metoda. Istnieje limit znaków, dopóki linia poleceń nie pokaże ci logów. Ponieważ logi są zbyt duże, aby obsłużyć je z linii poleceń, dlatego potrzebujemy handlerów plików.

Istnieje więcej handlerów takich jak mailhandlers, AdminEmailHandler itd.

AdminEmailHandler jest świetnym dodatkiem do modułu opensource.

Loggery są tymi, które rejestrują informacje o twoim serwerze lub oprogramowaniu. Loggery są również typem słownika. Ma on podobną architekturę jak handlery. Chociaż, istnieją różne atrybuty i inne właściwości.

Django również dostarcza zestaw loggerów. Istnieją różne loggery takie jak django, django.requests. i wiele innych.

Czy sprawdziłeś nasz ostatni Django request & response Tutorial

Teraz, aby zaimplementować logowanie, musisz po prostu wykonać następujące kroki:

Uruchom swój serwer.

$ python manage.py runserver

W momencie gdy wciśniesz enter, pojawi się seria logów i to bardzo dużo. Stało się tak, ponieważ ustawiliśmy domyślny poziom na debug. Wszystkie te logi to tak naprawdę wiadomości z domyślnych loggerów.

Możesz stworzyć swoje własne loggery w kolejnych plikach. W ten sposób możesz uzyskać logi z konkretnych plików.

Tutaj jest wyjście z pliku, który jest generowany po logowaniu.

To są logi. Jest wiele logów, ale tylko poziomy ostrzegawcze lub wyższe będą powiadamiane.

Podsumowanie

Logowanie jest dość ważne. Jeśli jest poprawnie zaimplementowane, to może zaoszczędzić ci sporo czasu. Generalnie, logowanie jest wykonywane po zakończeniu projektu.

Moduł logowania jest podstawą logowania w Django lub innym projekcie pythonowym. Istnieją również inne rozwiązania jak, selery, travis itp. Te logi ułatwiają również obsługę logów. Mogą one ułatwić zadanie wyszukiwania czy zdarzenia miały miejsce czy nie i co było ich przyczyną.

.