Jak zrobić kolor rejestrowania w Django/Google App Engine?

Question

Jeśli ktoś pisze aplikację Django/Google App Engine i chce mieć logi, które są dobrze widoczne w oparciu o kolory (tj. Błędy na czerwono), w jaki sposób można to ustawić?

Skopiowałem pomocne rozwiązanie z this question, ale nie jestem pewien, jak zintegrować go z Django/Google App Engine.

Pomyślałem należałoby umieścić następujące w main.py aplikacji (czyli zasadniczo od przykład tutaj: Running Django on Google App Engine):

from contrib.utils import ColouredLogger # from the SO question above 
logging.setLoggerClass(ColouredLogger) 

... gdzie contrib.utils ma gdzie umieścić kod airmind Pochodzi z powyżej link do jego odpowiedzi SO.

Jednak wydaje się, że nic nie robi z wyjściem na konsolę dla GAE, który nadal ma oryginalny format + zwykły kolor.

Sugestie i dane wejściowe będą mile widziane.

Cheers, Brian

Answer 1

Kody resetowania wymienione w odpowiedzi pan powiązany będzie działać na konsoli na lokalnym serwerze rozwoju (ale prawdopodobnie zajmie trochę szczypanie - musisz łańcucha ją z istniejącą Appler rejestrowania aplikacji Engine Engine), ale nie będzie działać w trybie produkcyjnym, ponieważ w dzienniku produkcji wpisy są wysyłane na stronę HTML w konsoli administracyjnej.

Można jednak filtrować według poziomu logowania w konsoli administratora.

Answer 2

Nie wierzę, że powinieneś stworzyć podklasę rejestratora właśnie w tym celu - odpowiedź airmind jest w porządku, jeśli chodzi o tworzenie wyspecjalizowanego Formatter i określenie jego użycia na StreamHandler. Ale nie ma potrzeby tworzenia podklasy rejestratora. W rzeczywistości wykorzystanie przez airmind klasy rejestratora dodaje program obsługi do każdego utworzonego rejestratora, co nie jest tym, czego potrzebujesz.

Rozwiązanie airmind dało tylko prace dla terminali obsługujących sekwencje specjalne ANSI - czy na pewno konsola je obsługuje?

Answer 3

Oto formater próbki:

class Formatter(logging.Formatter) : 
    _level_colors = { 
     "DEBUG": "\033[22;32m", "INFO": "\033[01;34m", 
     "WARNING": "\033[22;35m", "ERROR": "\033[22;31m", 
     "CRITICAL": "\033[01;31m" 
    };  

    def format(self, record): 
     if(Formatter._level_colors.has_key(record.levelname)): 
      record.levelname = "%s%s\033[0;0m" % \ 
          (Formatter._level_colors[record.levelname], 
          record.levelname) 
     record.name = "\033[37m\033[1m%s\033[0;0m" % record.name 
     return logging.Formatter.format(self, record)  

trzeba go skonfigurować, na przykład:

... 
[formatters] 
keys=console_formatter 
... 
[handler_console_handler] 
class=StreamHandler 
formatter=console_formatter 
args=(sys.stdout,) 

Answer 4

Chciałem też wyjście kolorów dla dev_appserver. Rozwiązania znalazłem tutaj trochę OTT (jedyne, czego chciałem, to aby moje wywołania logging.error() stały się wyjątkowe, skończyłem na monkeypatchingu modułu rejestrowania, upuszczając to w pliku main.py jako szybkie rozwiązanie:

# monkey patch logger to dump ERRORs in red 
import os 
if os.environ['SERVER_SOFTWARE'].find('Development') >= 0: 
    import logging 
    old_error = logging.error 
    def red_error(msg,*args,**kwargs): 
     old_error("\033[22;31m%s\033[0;0m" % msg, *args, **kwargs) 
    logging.error = red_error 

to będzie tylko dla terminali ANSI na kolorowych

Answer 5

używamy colorlog i robi dokładnie to, czego można oczekiwać

dla potomności, config formater używamy to:..

'color': { 
    '()': 'colorlog.ColoredFormatter', 
    'format': '%(log_color)s%(levelname)-8s %(message)s', 
    'log_colors': { 
     'DEBUG': 'bold_black', 
     'INFO':  'white', 
     'WARNING': 'yellow', 
     'ERROR': 'red', 
     'CRITICAL': 'bold_red', 
    }, 
} 

Answer 6

Django ma już obsługę kolorów wyjściowych za pomocą zmiennej środowiskowej "DJANGO_COLORS" używanej na przykład podczas uruchamiania wbudowanego serwera programistycznego.Ktoś zauważył to i stworzył rozwiązanie plug-and-play https://github.com/tiliv/django-colors-formatter; z tego pakietu na ścieżce Pythona projektu rejestrowanie settings.py moja jest następująca:

LOGGING = { 
    'version': 1, 
    'disable_existing_loggers': True, 
    'filters': { 
     'require_debug_false': { 
      '()': 'django.utils.log.RequireDebugFalse' 
     } 
    }, 
    'formatters': { 
     'verbose': { 
      '()': 'djangocolors_formatter.DjangoColorsFormatter', # colored output 
      'format': '%(levelname)s %(name)s %(asctime)s %(module)s %(process)d %(thread)d %(pathname)s@%(lineno)s: %(message)s' 
     }, 
     'simple': { 
      '()': 'djangocolors_formatter.DjangoColorsFormatter', # colored output 
      'format': '%(levelname)s %(name)s %(filename)s@%(lineno)s: %(message)s' 
     }, 
    }, 
    # omitting the handler 'level' setting so that all messages are passed and we do level filtering in 'loggers' 
    'handlers': { 
     'null': { 
      'class':'django.utils.log.NullHandler', 
     }, 
     'console':{ 
      'class':'logging.StreamHandler', 
      'formatter': 'simple', 
     }, 
     'mail_admins': { 
      'filters': ['require_debug_false'], 
      'class': 'django.utils.log.AdminEmailHandler', 
      'formatter': 'verbose' 
     } 
    }, 
    'loggers': { 
     '': { 
      'handlers': ['mail_admins', 'console'], 
      'level': 'WARNING', 
     }, 
    } 
} 

próbki wyjściowe rejestrowania konsola użyciu django-colors-formatowania: