精华内容
下载资源
问答
  • Django日志系统

    2018-12-28 14:24:00
    Django中使用的日志系统是基于Python中的loggin模块。 首先简单介绍下logging。 一 Loggin模块简介 loggin模块主要包含以下四个部分: Loggers 用户使用的直接接口,将日志传递给Handler Handlers 控制日志...

    在Django中使用的日志系统是基于Python中的loggin模块。 首先简单介绍下logging。

    一 Loggin模块简介

    loggin模块主要包含以下四个部分:

    • Loggers           用户使用的直接接口,将日志传递给Handler
    • Handlers          控制日志输出到哪里,console,file…    一个logger可以有多个Handler
    • Filters          控制哪些日志可以从logger流向Handler
    • Formatters       控制日志的格式

    1 Loggers  

    A logger is configured to have a log level. This log level describes the severity of the messages that the logger will handle. Python defines the following log levels:

    • DEBUG: Low level system information for debugging purposes            
    • INFO: General system information
    • WARNING: Information describing a minor problem that has occurred.
    • ERROR: Information describing a major problem that has occurred.
    • CRITICAL: Information describing a critical problem that has 

    每个日志信息都可以设定日志级别进行处理,

    当logger对象接收到了一条日志消息时会对log level进行比较, 如果log level超过或满足等自己的log level那么消息会交给handler进一步处理,否则会忽略这条消息。 

    2 Handlers

     handler决定了如何处理一条日志消息,它指定特定的日志记录行为比如将日志输出到屏幕或者输出到文件等等

     如何logger, handler也同样有log level 如果log level超过或满足等自己的log level那么消息会进一步处理,否则会忽略这条消息。

    一个logger可以有多个hanlder,每个hanlder可以有不同的log level 通过这种方式,可以根据消息的重要性提供不同形式的日志输出,比如你可以用一个handler进行ERROR和CRITCAL的页面输出,也可以同时用第二个hanlder把所有的日志级别输出到文件进行分析

    3 Filters 

    过滤器用于控制哪些日志可以从logger流向Handler

    默认情况下,将处理满足日志级别要求的任何日志消息。但是,通过过滤器,可以对日志记录过程设置附加条件。例如,可以配置一个过滤器,该过滤器仅允许从特定源发出ERROR消息。

     可以在logger或handle上安装筛选器, 也可以使用多个筛选器来执行多个筛选操作。

    4 Formatters

    formatters用于设定日志的输出格式, 输出格式的设置可以参考python LogRecord attributes

    字段/属性名称使用格式描述
    asctime %(asctime)s 日志事件发生的时间--人类可读时间,如:2003-07-08 16:49:45,896
    created %(created)f 日志事件发生的时间--时间戳,就是当时调用time.time()函数返回的值
    relativeCreated %(relativeCreated)d 日志事件发生的时间相对于logging模块加载时间的相对毫秒数(目前还不知道干嘛用的)
    msecs %(msecs)d 日志事件发生事件的毫秒部分
    levelname %(levelname)s 该日志记录的文字形式的日志级别('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
    levelno %(levelno)s 该日志记录的数字形式的日志级别(10, 20, 30, 40, 50)
    name %(name)s 所使用的日志器名称,默认是'root',因为默认使用的是 rootLogger
    message %(message)s 日志记录的文本内容,通过 msg % args计算得到的
    pathname %(pathname)s 调用日志记录函数的源码文件的全路径
    filename %(filename)s pathname的文件名部分,包含文件后缀
    module %(module)s filename的名称部分,不包含后缀
    lineno %(lineno)d 调用日志记录函数的源代码所在的行号
    funcName %(funcName)s 调用日志记录函数的函数名
    process %(process)d 进程ID
    processName %(processName)s 进程名称,Python 3.1新增
    thread %(thread)d 线程ID
    threadName %(thread)s 线程名称

     

    二 使用logging

    Once you have configured your loggers, handlers, filters and formatters, you need to place logging calls into your code. Using the logging framework is very simple. Here’s an example:

    # import the logging library
    import logging
    
    # Get an instance of a logger
    logger = logging.getLogger(__name__)
    
    def my_view(request, arg1, arg):
        ...
        if bad_mojo:
            # Log an error message
            logger.error('Something went wrong!')

    每当bad_mojo条件满足,都会发送一个error级别的日志记录。实例代码中的__name__代表logger的名称。 
    如果logger的定义如下,那么__name__就是’django’或’django.request’。

    'loggers': {
        ...
        'django': {
            'handlers': ['console'],
            'level': os.getenv('DJANGO_LOG_LEVEL', 'DEBUG'),
            'propagate': True,
        },
        'django.request': {
            'handlers': ['file', 'mail_admins'],
            'level': 'WARNING',
            'propagate': False,
        },
        ...
    }

    三 记录日志

    根据上述日志的5各级别,记录日志也有5个对应的方法。

    logger.debug()
    logger.info()
    logger.warning()
    logger.error()
    logger.critical()
    此外,还有两种日志方法

    logger.log() 手动记录一个日志,随便你想记录什么都行
    logger.exception() 为了捕获某些异常,创建一个ERROR级别的日志

    四 配置日志

    By default, the LOGGING setting is merged with Django’s default logging configuration using the following scheme.

    If the disable_existing_loggers key in the LOGGING dictConfig is set to True (which is the default) then all loggers from the default configuration will be disabled. Disabled loggers are not the same as removed; the logger will still exist, but will silently discard anything logged to it, not even propagating entries to a parent logger. Thus you should be very careful using 'disable_existing_loggers':True; it’s probably not what you want. Instead, you can set disable_existing_loggers to False and redefine some or all of the default loggers; or you can set LOGGING_CONFIG to None and handle logging config yourself.

    在django默认可以使用字典的形式配置, logger的配置都在setting.py中参考以下示例

    1 本地文件形式输出日志

    LOGGING = {
        'version': 1,
        'disable_existing_loggers': False,
        'handlers': {
            'file': {
                'level': 'DEBUG',
                'class': 'logging.FileHandler',
                'filename': '/path/to/django/debug.log',
            },
        },
        'loggers': {
            'django': {
                'handlers': ['file'],
                'level': 'DEBUG',
                'propagate': True,
            },
        },
    }

    2 在控制台中输出日志

    这种方式在本地开发环境进行调试时比较有帮助,很直观,需要的时候马上就能看到输出,不必切换到文件或者查收邮件。不过在生产环境下最好不要输出到控制台。默认情况下,只有在DEBUG = True的时候才会将日志输出到控制台,而且只处理INFO以上级别的日志。默认情况下,这种日志并不会输出很多信息,如果你想看到操作数据库的细节,可以在logger的level中设置'level': os.getenv('DJANGO_LOG_LEVEL', 'DEBUG'),这样就可以了。不过这样产生的日志也有点太多了。

    import os
    
    LOGGING = {
        'version': 1,
        'disable_existing_loggers': False,
        'handlers': {
            'console': {
                'class': 'logging.StreamHandler',
            },
        },
        'loggers': {
            'django': {
                'handlers': ['console'],
                'level': os.getenv('DJANGO_LOG_LEVEL', 'INFO'),
            },
        },
    }

     Finally, here’s an example of a fairly complex logging setup:

    LOGGING = {
        'version': 1,
        'disable_existing_loggers': False,
        'formatters': {
            'verbose': {
                'format': '{levelname} {asctime} {module} {process:d} {thread:d} {message}',
                'style': '{',
            },
            'simple': {
                'format': '{levelname} {message}',
                'style': '{',
            },
        },
        'filters': {
            'special': {
                '()': 'project.logging.SpecialFilter',
                'foo': 'bar',
            },
            'require_debug_true': {
                '()': 'django.utils.log.RequireDebugTrue',
            },
        },
        'handlers': {
            'console': {
                'level': 'INFO',
                'filters': ['require_debug_true'],
                'class': 'logging.StreamHandler',
                'formatter': 'simple'
            },
            'mail_admins': {
                'level': 'ERROR',
                'class': 'django.utils.log.AdminEmailHandler',
                'filters': ['special']
            }
        },
        'loggers': {
            'django': {
                'handlers': ['console'],
                'propagate': True,
            },
            'django.request': {
                'handlers': ['mail_admins'],
                'level': 'ERROR',
                'propagate': False,
            },
            'myproject.custom': {
                'handlers': ['console', 'mail_admins'],
                'level': 'INFO',
                'filters': ['special']
            }
        }
    }

    这个例子相比之前的会稍微复杂一些。
    formatters中有两个格式的配置,'verbose'和'simple',这里'simple'定义的输出格式很简单,因为只是用来输出一些INFO信息,并不是重要的日志,因此也并不需要复杂的格式。'verbose'输出的信息就比较丰富了,可以用在ERROR或CRITICAL日志的输出。具体的格式请参考这里。

    handlers中定义了两个handler:'console'和'mail_admins'。'console'配置'class': 'logging.StreamHandler',这个我们不用过多去说。重点看看'mail_admins',配置'class': 'django.utils.log.AdminEmailHandler',那么既然要配置为通过邮件发送日志,那么是不是有必要设置一下发送和接收的邮件呢?
    邮箱的配置也在settings.py中:

    # 邮件配置
    EMAIL_HOST = 'smtp.maildomain.com'  # SMTP地址
    EMAIL_PORT = 25  # SMTP端口
    EMAIL_HOST_USER = 'sender@maildomain.com'  # 发送邮件的邮箱
    EMAIL_HOST_PASSWORD = '******'  # 我的邮箱密码
    EMAIL_SUBJECT_PREFIX = u'[prefix]'  # 为邮件Subject-line前缀,默认是'[django]'
    EMAIL_USE_TLS = True  # 与SMTP服务器通信时,是否启动TLS链接(安全链接)。默认是false
    # 管理员站点
    SERVER_EMAIL = 'xinxinyu2011@163.com'  # The email address that error messages come from, such as those sent to ADMINS and MANAGERS.
    ADMINS = (('receiver', 'receiver@maildomain.com'),)  # 接收邮件的邮箱(或邮件组)

     三个logger配置

    • django, which passes all messages to the console handler.
    • django.request, which passes all ERROR messages to the mail_admins handler. In addition, this logger is marked to notpropagate messages. This means that log messages written to django.request will not be handled by the django logger.
    • myproject.custom, which passes all messages at INFO or higher that also pass the special filter to two handlers – the console, and mail_admins. This means that all INFO level messages (or higher) will be printed to the console; ERROR and CRITICAL messages will also be output via email.

    3 Django提供的内置logger

    Django提供了一些内建的logger,比如上面例子中的'django'。

    django
    'django'只是一个最上级的logger,但实际上并不接收什么实际的信息,所有的信息都是通过下级logger接收。

    django.request
    django.request是要受理关于请求(request)的日志记录。如果response是5XX,则被认为是ERROR级别的日志信息,4XX则是WARNING级别。

    django.server
    django.server是要受理关于服务器端处理请求的结果的日志记录。如果response是5XX,则被认为是ERROR级别的日志信息,4XX则是WARNING级别,其他的都是INFO级别。

    django.template
    django.template受理关于模板(templates)的信息。语法错误是DEBUG级别,未被捕获的异常会产生WARNING。

    django.db.backends
    django.db.backends受理代码与数据库交互过程产生的日志信息。只记录application级别的SQL操作信息,并且都会产生DEBUG级别的信息。信息中包含耗时、SQL语句、参数信息。此logger只能在DEBUG = True时才有效。
    这个logger并不记录framework-level的信息,如SET TIMEZONE,也不记录事务管理相关的查询,如BEGIN、COMMIT、ROLLBACK等。想知道这方面的信息,只有去查数据库的日志了,Django并不提供。


    转载于:https://www.cnblogs.com/harryblog/p/10190342.html

    展开全文
  • django 日志系统

    千次阅读 2017-12-20 16:21:00
    django使用python内建的logging模块去建造自己的系统日志的,如果你想详细了解这个模块的话,请自己去看python的说明文档,这里仅仅介绍django中的日志系统 日志配置包括四个部分:记录器,处理器,过滤器和格式器...

    我的代码:

    1.settings.py文件中

    #django日志系统
    LOGGING = {
        'version': 1,
        'disable_existing_loggers': False,
        'filters': {
            'require_debug_true': {
                '()': 'django.utils.log.RequireDebugTrue',
            }, # 针对 DEBUG = True 的情况
        },
        'formatters': {
            'standard': {
                'format': '%(levelname)s %(asctime)s %(pathname)s %(filename)s %(module)s %(funcName)s %(lineno)d: %(message)s'
            }, # 对日志信息进行格式化,每个字段对应了日志格式中的一个字段,更多字段参考官网文档,我认为这些字段比较合适,输出类似于下面的内容
            # INFO 2016-09-03 16:25:20,067 /home/ubuntu/mysite/views.py views.py views get 29: some info...
        },
        'handlers': {
            'mail_admins': {
                'level': 'ERROR',
                'class': 'django.utils.log.AdminEmailHandler',
                 'formatter':'standard'
            },
            'file_handler': {
                 'level': 'DEBUG',
                 'class': 'logging.handlers.TimedRotatingFileHandler',
                 'filename': os.path.join(BASE_DIR, "logging\\test.log"),   #网上的报错,改成相对路径
                 'formatter':'standard'
            }, # 用于文件输出
            'console':{
                'level': 'INFO',
                'filters': ['require_debug_true'],
                'class': 'logging.StreamHandler',
                'formatter': 'standard'
            },
        },
        'loggers': {
            'django': {
                'handlers' :['file_handler', 'console'],
                'level':'DEBUG',
                'propagate': True # 是否继承父类的log信息
            }, # handlers 来自于上面的 handlers 定义的内容
            'django.request': {
                'handlers': ['mail_admins'],
                'level': 'ERROR',
                'propagate': False,
            },
        }
    }
    

    2.在views.py中调用,不知道是不是每个都需要调用,暂时都调用了

    #记录日志
    import logging
    logger = logging.getLogger("django") # loggers中定义的名称
    logger.info("some info...")
    


    3.得到了报错日志,该文件下有所有的信息。



    4.若想单独打印bug信息,则需要根据对应的函数自己写try except然后打日志。这步还没做。




    另外一篇简单的配置博文:

    http://blog.csdn.net/novostary/article/details/52424116

    django使用python内建的logging模块去建造自己的系统日志的,如果你想详细了解这个模块的话,请自己去看python的说明文档,这里仅仅介绍django中的日志系统

    日志配置包括四个部分:记录器,处理器,过滤器和格式器,下面我们来一一讲解

    记录器

    一个记录器是日志系统的一个实体,每一个记录器是一个已经命名好的可以将消息为进程写入的“桶”。

    每一个记录器都会有一个日志等级,每个等级描述了记录器即将处理的信息的严重性,python定义了以下五个等级:

    debug:出于调试目的的低层次系统信息

    • info:普通的系统信息
    • warning:描述已经发生的小问题
    • error:描述已经发生的主要问题
    • critical:描述已经发生的严重问题

    每一条被写入记录器的信息成为一条日志记录,每条日志记录都有一个表明该记录严重性的日志等级,每条日志信息也会包含一些有用的元信息表明已经被记录的事件,比如栈追溯和错误代码。

    当一条信息被发往记录器的时候,消息的记录等级会和记录器的等级相比较,如果符合甚至超越当前等级,则被发往处理器处理,否则会被忽略掉。

    处理器

    处理器是决定日志记录器中对应的实体消息发生了什么的引擎,描述了一个具体的日志行为,比如输出到屏幕,或者一个文件,抑或一个网络socket。

    和记录器一样,没有到达相应等级的消息会被忽略。

    一个记录器可以有多个处理器,一个处理器可以有不同的日志等级,因此你可以根据消息的重要性而提供不同的提示。

    过滤器

    过滤器是用来提供额外的控制,控制哪些日志记录可以被传给处理器处理。

    默认情况下,只要日志消息符合相应的等级要求就会传给对应的处理器处理,然而,通过安装过滤器,你可以在日志记录过程中设置额外的内容,例如,你可以安装一个过滤器使得某个源只有error级别的消息才会被发送。你也可以使用过滤器修改之前会被发送的消息,例如,你可以写一个过滤器使得符合某些条件的error等级的消息降级为warning等级。

    过滤器可以给处理器和记录器使用,多个过滤器可以级联使用。

    格式器

    控制日志输出的格式,格式使用python的字符串控制格式

    使用日志

    一旦配置好你的记录器,处理器,过滤器和格式器,你需要在你的代码中调用日志功能,下面是一个简单的例子:

    复制代码
    复制代码
    # import the logging library
    import logging
    
    # Get an instance of a logger
    logger = logging.getLogger(__name__)
    
    def my_view(request, arg1, arg):
        ...
        if bad_mojo:
            # Log an error message
            logger.error('Something went wrong!')
    复制代码
    复制代码

     

    命名你的记录器

    logging.getLogger()的调用获得一个记录器的实体,记录器实体通过名字来辨别。

    像上面的那个例子,一般是使用__name__,包含记录器的python模块的名字,这使得基于每个模块的记录成为可能

    或者你可以是用点号相连的名字,这意味着记录器的层次,点号之前的是点号之后的父模块,例如

    # Get an instance of a specific named logger
    logger = logging.getLogger('project.interesting.stuff')

     

    这种方式也很重要,因为通过层次,子层次的消息可以把消息发送给自己的父层次,如果你不想把消息发给你的父层次,记得把发送开关关闭掉。(下面会有介绍到)

    日志调用

    对应日志的五个等级,日志调用有五个对应的方法:

    • logger.critical()
    • logger.error()
    • logger.warning()
    • logger.info()
    • logger.debug()

    还有两个可用的日志方法可以调用:

    • logger.log():手工发送一个具体等级的日志消息
    • logger.exception():创建一个error等级的封装着异常堆栈帧内容的日志消息

    配置日志系统

    在代码中调用日志的前提是已经配置好了日志系统的记录器,处理器,过滤器和格式器,我们通过一个复杂的例子来详细讲解吧:

    复制代码
    复制代码
    LOGGING = {
        'version': 1,#指明dictConnfig的版本,目前就只有一个版本,哈哈
        'disable_existing_loggers': True,#禁用所有的已经存在的日志配置
        'formatters': {#格式器
            'verbose': {#详细
                'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
            },
            'simple': {#简单
                'format': '%(levelname)s %(message)s'
            },
        },
        'filters': {#过滤器
            'special': {#使用project.logging.SpecialFilter,别名special,可以接受其他的参数
                '()': 'project.logging.SpecialFilter',
                'foo': 'bar',#参数,名为foo,值为bar
            }
        },
        'handlers': {#处理器,在这里定义了三个处理器
            'null': {#Null处理器,所有高于(包括)debug的消息会被传到/dev/null
                'level':'DEBUG',
                'class':'django.utils.log.NullHandler',
            },
            'console':{#流处理器,所有的高于(包括)debug的消息会被传到stderr,使用的是simple格式器
                'level':'DEBUG',
                'class':'logging.StreamHandler',
                'formatter': 'simple'
            },
            'mail_admins': {#AdminEmail处理器,所有高于(包括)而error的消息会被发送给站点管理员,使用的是special格式器
                'level': 'ERROR',
                'class': 'django.utils.log.AdminEmailHandler',
                'filters': ['special']
            }
        },
        'loggers': {#定义了三个记录器
            'django': {#使用null处理器,所有高于(包括)info的消息会被发往null处理器,向父层次传递信息
                'handlers':['null'],
                'propagate': True,
                'level':'INFO',
            },
            'django.request': {#所有高于(包括)error的消息会被发往mail_admins处理器,消息不向父层次发送
                'handlers': ['mail_admins'],
                'level': 'ERROR',
                'propagate': False,
            },
            'myproject.custom': {#所有高于(包括)info的消息同时会被发往console和mail_admins处理器,使用special过滤器
                'handlers': ['console', 'mail_admins'],
                'level': 'INFO',
                'filters': ['special']
            }
        }
    }
    复制代码
    复制代码

     

    相信看完这个例子,对日志系统的配置大家基本了解了吧

    循环导入问题

    如果你自定义了一个处理器,然后再settings.py文件有配置,如果这是你在类实现文件里面导入settings模块的时候,就会出现循环导入的问题,建议只在settings.py配置文件里面配置

    自定义日志配置和禁用日志配置

    使用LOGGING_CONFIG属性自定义和禁用日志配置,LOGGING_CONFIG=None禁用

    django日志拓展

    django提供三个自带的记录器:

    django

    django记录器是捕捉所有消息的记录器,没有消息是直接发往django记录器的

    django.request

    5XX会引发一个error消息,4XX会引发一个warning消息,这个记录器还附带有额外的上下文:

    • status_code:HTTP响应吗
    • request:生成这个消息的request对象

    django.db.backens

    所有的由请求运行的sql语句都会记录一条debug的消息,每个记录器还附带有额外的上下文:

    • duration:sql语句运行的时间
    • sql:运行的sql语句
    • params:sql语句调用的参数

    处于网站运行的表现原因,仅当settings.DEBUG=True的时候,这个处理器才生效,否则即使配置了也无效

    除了python模块自带的,django自定义了一个处理器

    class AdminEmailHandler(include_html=False)

    这个处理器每收到一条消息就会发往站点管理员,如果日志信息包含request属性,那么整个request的详细信息也会被包包含在Email中发往站点管理员;如果日志信息包含堆栈跟踪信息,堆栈跟踪信息也会被发送。

    include_html属性控制当DEBUG为真的时候是否发送那些回溯信息,因为这些都是很敏感的系统系统,如果被人截获,可能会发生危险,所以要谨慎。配置这个属性示例如下:

    复制代码
    复制代码
    'handlers': {
        'mail_admins': {
            'level': 'ERROR',
            'class': 'django.utils.log.AdminEmailHandler',
            'include_html': True,
        }
    },
    复制代码
    复制代码

     

    除了python自带的,django提供了两个自带的过滤器:

    class CallBackFilter(callback)

    这个过滤器接受一个回调函数(这个函数接受一个参数,被记录的信息),每个记录通过过滤器的时候都会调用这个回调函数,当回调函数返回False的时候,不处理这个记录。下面是一个示例:

    复制代码
    复制代码
    from django.http import UnreadablePostError
    
    def skip_unreadable_post(record):
        if record.exc_info:
            exc_type, exc_value = record.exc_info[:2]
            if isinstance(exc_value, UnreadablePostError):
                return False
        return True
    复制代码
    复制代码
    复制代码
    复制代码
    'filters': {
        'skip_unreadable_posts': {
            '()': 'django.utils.log.CallbackFilter',
            'callback': skip_unreadable_post,
        }
    },
    'handlers': {
        'mail_admins': {
            'level': 'ERROR',
            'filters': ['skip_unreadable_posts'],
            'class': 'django.utils.log.AdminEmailHandler'
        }
    },
    复制代码
    复制代码

     

    class RequireDebugFalse

    这个过滤器仅当settings.DEBUG为False的时候会生效,默认是启用的,仅当settings.DEBUG=False的时候,AdminEmailHandler才生效

    复制代码
    复制代码
    'filters': {
         'require_debug_false': {
             '()': 'django.utils.log.RequireDebugFalse',
         }
     },
     'handlers': {
         'mail_admins': {
             'level': 'ERROR',
             'filters': ['require_debug_false'],
             'class': 'django.utils.log.AdminEmailHandler'
         }
     },
    复制代码
    复制代码
    展开全文
  • 18:django 日志系统

    2019-10-07 12:21:34
    django使用python内建的logging模块去建造自己的系统日志的,如果你想详细了解这个模块的话,请自己去看python的说明文档,这里仅仅介绍django中的日志系统 日志配置包括四个部分:记录器,处理器,过滤器和格式器...

    django使用python内建的logging模块去建造自己的系统日志的,如果你想详细了解这个模块的话,请自己去看python的说明文档,这里仅仅介绍django中的日志系统

    日志配置包括四个部分:记录器,处理器,过滤器和格式器,下面我们来一一讲解

    记录器

    一个记录器是日志系统的一个实体,每一个记录器是一个已经命名好的可以将消息为进程写入的“桶”。

    每一个记录器都会有一个日志等级,每个等级描述了记录器即将处理的信息的严重性,python定义了以下五个等级:

    debug:出于调试目的的低层次系统信息

    • info:普通的系统信息
    • warning:描述已经发生的小问题
    • error:描述已经发生的主要问题
    • critical:描述已经发生的严重问题

    每一条被写入记录器的信息成为一条日志记录,每条日志记录都有一个表明该记录严重性的日志等级,每条日志信息也会包含一些有用的元信息表明已经被记录的事件,比如栈追溯和错误代码。

    当一条信息被发往记录器的时候,消息的记录等级会和记录器的等级相比较,如果符合甚至超越当前等级,则被发往处理器处理,否则会被忽略掉。

    处理器

    处理器是决定日志记录器中对应的实体消息发生了什么的引擎,描述了一个具体的日志行为,比如输出到屏幕,或者一个文件,抑或一个网络socket。

    和记录器一样,没有到达相应等级的消息会被忽略。

    一个记录器可以有多个处理器,一个处理器可以有不同的日志等级,因此你可以根据消息的重要性而提供不同的提示。

    过滤器

    过滤器是用来提供额外的控制,控制哪些日志记录可以被传给处理器处理。

    默认情况下,只要日志消息符合相应的等级要求就会传给对应的处理器处理,然而,通过安装过滤器,你可以在日志记录过程中设置额外的内容,例如,你可以安装一个过滤器使得某个源只有error级别的消息才会被发送。你也可以使用过滤器修改之前会被发送的消息,例如,你可以写一个过滤器使得符合某些条件的error等级的消息降级为warning等级。

    过滤器可以给处理器和记录器使用,多个过滤器可以级联使用。

    格式器

    控制日志输出的格式,格式使用python的字符串控制格式

    使用日志

    一旦配置好你的记录器,处理器,过滤器和格式器,你需要在你的代码中调用日志功能,下面是一个简单的例子:

    # import the logging library
    import logging
    
    # Get an instance of a logger
    logger = logging.getLogger(__name__)
    
    def my_view(request, arg1, arg):
        ...
        if bad_mojo:
            # Log an error message
            logger.error('Something went wrong!')

     

    命名你的记录器

    logging.getLogger()的调用获得一个记录器的实体,记录器实体通过名字来辨别。

    像上面的那个例子,一般是使用__name__,包含记录器的python模块的名字,这使得基于每个模块的记录成为可能

    或者你可以是用点号相连的名字,这意味着记录器的层次,点号之前的是点号之后的父模块,例如

    # Get an instance of a specific named logger
    logger = logging.getLogger('project.interesting.stuff')

     

    这种方式也很重要,因为通过层次,子层次的消息可以把消息发送给自己的父层次,如果你不想把消息发给你的父层次,记得把发送开关关闭掉。(下面会有介绍到)

    日志调用

    对应日志的五个等级,日志调用有五个对应的方法:

    • logger.critical()
    • logger.error()
    • logger.warning()
    • logger.info()
    • logger.debug()

    还有两个可用的日志方法可以调用:

    • logger.log():手工发送一个具体等级的日志消息
    • logger.exception():创建一个error等级的封装着异常堆栈帧内容的日志消息

    配置日志系统

    在代码中调用日志的前提是已经配置好了日志系统的记录器,处理器,过滤器和格式器,我们通过一个复杂的例子来详细讲解吧:

    LOGGING = {
        'version': 1,#指明dictConnfig的版本,目前就只有一个版本,哈哈
        'disable_existing_loggers': True,#禁用所有的已经存在的日志配置
        'formatters': {#格式器
            'verbose': {#详细
                'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
            },
            'simple': {#简单
                'format': '%(levelname)s %(message)s'
            },
        },
        'filters': {#过滤器
            'special': {#使用project.logging.SpecialFilter,别名special,可以接受其他的参数
                '()': 'project.logging.SpecialFilter',
                'foo': 'bar',#参数,名为foo,值为bar
            }
        },
        'handlers': {#处理器,在这里定义了三个处理器
            'null': {#Null处理器,所有高于(包括)debug的消息会被传到/dev/null
                'level':'DEBUG',
                'class':'django.utils.log.NullHandler',
            },
            'console':{#流处理器,所有的高于(包括)debug的消息会被传到stderr,使用的是simple格式器
                'level':'DEBUG',
                'class':'logging.StreamHandler',
                'formatter': 'simple'
            },
            'mail_admins': {#AdminEmail处理器,所有高于(包括)而error的消息会被发送给站点管理员,使用的是special格式器
                'level': 'ERROR',
                'class': 'django.utils.log.AdminEmailHandler',
                'filters': ['special']
            }
        },
        'loggers': {#定义了三个记录器
            'django': {#使用null处理器,所有高于(包括)info的消息会被发往null处理器,向父层次传递信息
                'handlers':['null'],
                'propagate': True,
                'level':'INFO',
            },
            'django.request': {#所有高于(包括)error的消息会被发往mail_admins处理器,消息不向父层次发送
                'handlers': ['mail_admins'],
                'level': 'ERROR',
                'propagate': False,
            },
            'myproject.custom': {#所有高于(包括)info的消息同时会被发往console和mail_admins处理器,使用special过滤器
                'handlers': ['console', 'mail_admins'],
                'level': 'INFO',
                'filters': ['special']
            }
        }
    }

     

    相信看完这个例子,对日志系统的配置大家基本了解了吧

    循环导入问题

    如果你自定义了一个处理器,然后再settings.py文件有配置,如果这是你在类实现文件里面导入settings模块的时候,就会出现循环导入的问题,建议只在settings.py配置文件里面配置

    自定义日志配置和禁用日志配置

    使用LOGGING_CONFIG属性自定义和禁用日志配置,LOGGING_CONFIG=None禁用

    django日志拓展

    django提供三个自带的记录器:

    django

    django记录器是捕捉所有消息的记录器,没有消息是直接发往django记录器的

    django.request

    5XX会引发一个error消息,4XX会引发一个warning消息,这个记录器还附带有额外的上下文:

    • status_code:HTTP响应吗
    • request:生成这个消息的request对象

    django.db.backens

    所有的由请求运行的sql语句都会记录一条debug的消息,每个记录器还附带有额外的上下文:

    • duration:sql语句运行的时间
    • sql:运行的sql语句
    • params:sql语句调用的参数

    处于网站运行的表现原因,仅当settings.DEBUG=True的时候,这个处理器才生效,否则即使配置了也无效

    除了python模块自带的,django自定义了一个处理器

    class AdminEmailHandler(include_html=False)

    这个处理器每收到一条消息就会发往站点管理员,如果日志信息包含request属性,那么整个request的详细信息也会被包包含在Email中发往站点管理员;如果日志信息包含堆栈跟踪信息,堆栈跟踪信息也会被发送。

    include_html属性控制当DEBUG为真的时候是否发送那些回溯信息,因为这些都是很敏感的系统系统,如果被人截获,可能会发生危险,所以要谨慎。配置这个属性示例如下:

    'handlers': {
        'mail_admins': {
            'level': 'ERROR',
            'class': 'django.utils.log.AdminEmailHandler',
            'include_html': True,
        }
    },

     

    除了python自带的,django提供了两个自带的过滤器:

    class CallBackFilter(callback)

    这个过滤器接受一个回调函数(这个函数接受一个参数,被记录的信息),每个记录通过过滤器的时候都会调用这个回调函数,当回调函数返回False的时候,不处理这个记录。下面是一个示例:

    from django.http import UnreadablePostError
    
    def skip_unreadable_post(record):
        if record.exc_info:
            exc_type, exc_value = record.exc_info[:2]
            if isinstance(exc_value, UnreadablePostError):
                return False
        return True
    'filters': {
        'skip_unreadable_posts': {
            '()': 'django.utils.log.CallbackFilter',
            'callback': skip_unreadable_post,
        }
    },
    'handlers': {
        'mail_admins': {
            'level': 'ERROR',
            'filters': ['skip_unreadable_posts'],
            'class': 'django.utils.log.AdminEmailHandler'
        }
    },

     

    class RequireDebugFalse

    这个过滤器仅当settings.DEBUG为False的时候会生效,默认是启用的,仅当settings.DEBUG=False的时候,AdminEmailHandler才生效

    'filters': {
         'require_debug_false': {
             '()': 'django.utils.log.RequireDebugFalse',
         }
     },
     'handlers': {
         'mail_admins': {
             'level': 'ERROR',
             'filters': ['require_debug_false'],
             'class': 'django.utils.log.AdminEmailHandler'
         }
     },

     

    转载于:https://www.cnblogs.com/qwj-sysu/p/4218536.html

    展开全文
  • Python Django项目日志查询系统

    万次阅读 2020-08-07 18:06:11
    该项目适合中小型公司日志查询工作。大型公司可以使用elk等。 日志查询系统 维护手册 作者:陈土锋 ...

    该项目适合中小型公司日志查询工作。大型公司可以使用elk等。该系统其实就是调用了absible命令去查日志,然后把输出的信息输到页面查看。
    本工具是本人从 0 - 1 全程开发的,还有很多地方需要优化。

     项目由来:
    本人曾任职于一家移动外包公司,服务器用的是内网,出口有移动的防火墙,所以相对云服务器绝对的安全。内部组件基本都是内网通信。只有对外的web页面或者后台做了外网域名的端口映射。
    因为移动限制了研发登录内网机器查看日志,elk也是有的,但是接入麻烦,两头对接,降低效率的同时也得不到自己想要的日志。只有直接使用系统命令去查找才能看到最原始的日志,才方便问题排查。
    故开发了此组件,便于研发查找原始日志。虽然目前本人已离职,但据听说该组件还一直在使用,虽然已无人维护更新迭代,但足以支撑目前那个项目的使用。


    项目代码git地址:
    https://github.com/MYF12/logsquery3.0.git

    有问题可联系本人QQ:1016401546

                                           日志查询系统

                                                                              维护手册
                                                                             作者:陈土锋
                                                                          日期:2020年6月11日

    目录

    前言... 1

    一、系统底层逻辑说明... 2

    二、环境说明... 2

    三、系统搭建... 2

    3.1 安装Python3. 2

    3.1.1 安装依赖环境... 2

    3.1.2下载Python3. 3

    3.1.3 安装Python3. 3

    3.1.4 建立Python3和pip3的软链:. 3

    3.1.5 并将/usr/local/python3/bin加入PATH. 3

    3.2 安装虚拟环境... 4

    3.2.1 生产环境虚拟环境包路径:... 4

    3.2.2 先安装distlib-0.3.0.zip. 4

    3.2.3 创建虚拟环境... 5

    3.3 安装Django. 6

    3.4 测试项目是否正常运行... 7

    3.4.1 项目部署... 7

    3.4.2 项目测试... 8

    四、nginx+uwsgi+Django代理项目... 8

    4.1 安装uwsgi 8

    4.2 配置uwsgi 9

    4.3 启动uwsgi 10

    4.4 配置nginx 代理Django. 10

    五、Django3.0.7安装... 12

     

    前言

    1、该程序是根据xxxxxx目前系统管理层面开发而成,故仅适用于xxxxxx系统平台。
    2、该系统开发初心为减少运维协助研发查询线上生产日志、线上配置和线上其他环境而开发出来的。
    3、架构使用了Python3+Django+uwsgi+nginx 基础架构。
    4、底层调用ansible命令
     

     

    一、系统底层逻辑说明

    1.1 前端代码通过form表单提交用户交互信息到后端。
    1.2 后端接受到输入信息,经过逻辑处理之后调用服务器的ansible命令来执行远程命令。
    1.3 远程命令返回的结果,再通过文本格式展示到前端页面供用户查看。
    1.4 如果文本文件行数过多,则用户可以通过下载的连接下载到文本到本地查看查看。 
     

     

    二、环境说明

     
    2.1 服务器安装ansible命令(前提)
    2.2 ansible服务器必须能通过下面命令格式去执行远程命令:
    如:ansible slivr --sudo -m shell -a "ls -l "
    如果是root用户则在sudoer文件加入root用户sudo权限即可,这样无需修改代码。
    2.3 安装Python3
    2.4 安装虚拟环境
    2.5 安装Django 1.8 版本(最新版Django3.5需要改下代码的URL转发方式)
     

    三、系统搭建

    3.1 安装Python3

    3.1.1 安装依赖环境

    输入命令:yum -y install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel

     

    3.1.2下载Python3

    1.进入opt文件目录下,cd opt/
    2.下载python3   (可以到官方先看最新版本多少)
    输入命令 wget https://www.python.org/ftp/python/3.7.1/Python-3.7.1.tgz
     

    3.1.3 安装Python3

    安装在/usr/local/python3(具体安装位置看个人喜好)
    (1)创建目录:  mkdir -p /usr/local/python3
    (2)解压下载好的Python-3.x.x.tgz包(具体包名因你下载的Python具体版本不不同⽽而不不同,如:我下载的是Python3.7.1.那我这里就是Python-3.7.1.tgz)
    输入命令 tar -zxvf Python-3.7.1.tgz
    解压后出现python的文件夹
    进入解压后的目录,编译安装。(编译安装前需要安装编译器yum install gcc)
    (3)进入python文件夹,生成编译脚本(指定安装目录):
     cd Python-3.7.1
    ./configure --prefix=/usr/local/python3  
    #/usr/local/python3为上面步骤创建的目录
    (4)编译:make
    (5)编译成功后,编译安装:make install
    安装成功:
    (6)检查python3.7的编译器:/usr/local/python3/bin/python3.7

    3.1.4 建立Python3和pip3的软链:

    ln -s /usr/local/python3/bin/python3 /usr/bin/python3
    ln -s /usr/local/python3/bin/pip3 /usr/bin/pip3

    3.1.5 并将/usr/local/python3/bin加入PATH

    (1)vim /etc/profile
    (2)按“I”,然后贴上下面内容:

    # vim ~/.bash_profile
    # .bash_profile
    # Get the aliases and functions
    if [ -f ~/.bashrc ]; then
    . ~/.bashrc
    fi
    # User specific environment and startup programs
    PATH=$PATH:$HOME/bin:/usr/local/python3/bin
    export PATH
    source ~/.bash_profile

     

     

    3.2 安装虚拟环境

    3.2.1 生产环境虚拟环境包路径:/xxxx/xxxx/

    使用pip3下载下面命令:

    vim requirements.txt
    appdirs==1.4.3
    distlib==0.3.0
    filelock==3.0.12
    importlib-metadata==1.6.0
    importlib-resources==1.4.0
    pbr==5.4.5
    setuptools==39.0.1
    six==1.14.0
    stevedore==1.32.0
    virtualenv==20.0.18
    virtualenv-clone==0.5.4
    virtualenvwrapper==4.8.2
    zipp==3.1.0
    #下载
    pip3 download requirements.txt

    下载完之后可以看到下面这些包:

    appdirs-1.4.3-py2.py3-none-any.whl
    distlib-0.3.0.zip
    filelock-3.0.12-py3-none-any.whl
    importlib_metadata-1.6.0-py2.py3-none-any.whl
    importlib_resources-1.4.0-py2.py3-none-any.whl
    pbr-5.4.5-py2.py3-none-any.whl
    six-1.14.0-py2.py3-none-any.whl
    stevedore-1.32.0-py2.py3-none-any.whl
    virtualenv-20.0.18-py2.py3-none-any.whl
    virtualenv_clone-0.5.4-py2.py3-none-any.whl
    virtualenvwrapper-4.8.2-py2.py3-none-any.whl
    zipp-3.1.0-py3-none-any.whl

     

    3.2.2 先安装distlib-0.3.0.zip

    unzip distlib-0.3.0.zip
    cd distlib-0.3.0
    python3 setup.py build
    python3 setup.py install
    再安装所有的whl包:
    pip3 install *.whl

    3.2.3 配置环境

    mkdir /root/.virtualenvs
    #用locate virtualenvwrapper.sh 找出这个文件的路径,一般在安装的python3 bin目录下
    vim ~/.bashrc 
    export WORKON_HOME=/root/.virtualenvs 
    #加载环境
    source /usr/local/python3/bin/virtualenvwrapper.sh

    vim  /usr/local/python3/bin/virtualenvwrapper.sh
    找到VIRTUALENVWRAPPER_PYTHON关键字,在下面的if上面添加红色代码,python路径要对。

    VIRTUALENVWRAPPER_PYTHON=/usr/local/python3/bin/python3
    if [ "${VIRTUALENVWRAPPER_PYTHON:-}" = "" ]
    then
    source ~/.bashrc

    做virtualenv命令软连接:否则后续创建虚拟环境会报错

    ln -s /usr/local/python3/bin/virtualenv /usr/bin/virtualenv

    [root@ansible-server2 dwlirui2]# pip3 list --可以看到已经安装了下面的包
    Package Version
    ------------------- -------
    appdirs 1.4.3
    distlib 0.3.0
    filelock 3.0.12
    importlib-metadata 1.6.0
    importlib-resources 1.4.0
    pbr 5.4.5
    pip 20.0.2
    setuptools 39.0.1
    six 1.14.0
    stevedore 1.32.0
    virtualenv 20.0.18
    virtualenv-clone 0.5.4
    virtualenvwrapper 4.8.2
    zipp 3.1.0

     

    3.2.3 创建虚拟环境

    [root@ansible-server2 dwlirui2]# mkvirtualenv -p python3 env1

    创建成功之后你会默认进入虚拟环境,如创建env1:

    [root@ansible-server2 dwlirui2]# mkvirtualenv -p python3 env1
    created virtual environment CPython3.6.5.final.0-64 in 1210ms
      creator CPython3Posix(dest=/root/.virtualenvs/env3, clear=False, global=False)
      seeder FromAppData(download=False, pip=latest, setuptools=latest, wheel=latest, via=copy, app_data_dir=/root/.local/share/virtualenv/seed-app-data/v1.0.1)
      activators BashActivator,CShellActivator,FishActivator,PowerShellActivator,PythonActivator,XonshActivator
    virtualenvwrapper.user_scripts creating /root/.virtualenvs/env3/bin/predeactivate
    virtualenvwrapper.user_scripts creating /root/.virtualenvs/env3/bin/postdeactivate
    virtualenvwrapper.user_scripts creating /root/.virtualenvs/env3/bin/preactivate
    virtualenvwrapper.user_scripts creating /root/.virtualenvs/env3/bin/postactivate
    virtualenvwrapper.user_scripts creating /root/.virtualenvs/env3/bin/get_env_details

    可以看到你已经进入虚拟环境env1,这个虚拟环境里面安装的软件和外面环境分开的

    (env1) [root@ansible-server2 dwlirui2]#

     

    3.3 安装Django

    通过旧的虚拟环境导出来的包:存放到requirements.txt文件里面。
    旧环境登陆虚拟环境执行导出命令:pip3 freeze >requirements.txt

    cat requirements.txt --下载如下包
    certifi==2020.4.5.1
    chardet==3.0.4
    Django==1.8.2
    idna==2.9
    requests==2.23.0
    urllib3==1.25.8

    然后找一台测试环境能联网的机器下载这些包:

    [root@vm44 django_instaa]# pip3 download -r requirements.txt
    [root@vm44 django_instaa]# ls --总共下载了下面这么多包
    backcall-0.1.0.tar.gz idna-2.9-py2.py3-none-any.whl
    backcall-0.1.0.zip requests-2.23.0-py2.py3-none-any.whl
    certifi-2020.4.5.1-py2.py3-none-any.whl requirements.txt
    chardet-3.0.4-py2.py3-none-any.whl
    distlib-0.3.0.zip urllib3-1.25.8-py2.py3-none-any.whl
    Django-1.8.2-py2.py3-none-any.whl

    scp * root@xx.xx.xx.xx:/data/python_install/django_install --把包传到远程离线服务器
    离线服务器登陆虚拟环境
    workon env1 --以下命令均在虚拟环境执行
    cd /data/python_install/django_install
    离线虚拟环境先安装:backcall-0.1.0.zip,distlib-0.3.0.zip
    以安装backcall-0.1.0.zip为例:

    unzip backcall-0.1.0.zip
    cd backcall-0.1.0
    python3 setup.py build
    python3 setup.py install
    再安装所有的whl包:
    pip3 install *.whl

    安装完了之后,确定是否存在下面这些包:

    [root@ansible-server2 logs]# workon  env1
     (env1) [root@ansible-server2 logs]# pip list
    Package    Version  
    ---------- ----------
    backcall   0.1.0    
    certifi    2020.4.5.1
    chardet    3.0.4    
    distlib    0.3.0    
    Django     1.8.2    
    idna       2.9      
    pip        20.0.2   
    requests   2.23.0   
    setuptools 46.1.3   
    urllib3    1.25.8   
    uWSGI      2.0.18   
    wheel      0.34.2 
    

    3.4 测试项目是否正常运行

    我是通过虚拟环境搭建这个的,nginx安装到服务器上面,uwsgi和Django部署到虚拟环境上面。uwsgi和Django在虚拟环境启动。nginx 在服务器层面启动。
    项目代码已经备份到xx.xx.xx.xx:/share/logs_bak/xx.xx.xx.xx/ logsquerybak/logsquery.20200601.tar.gz

    3.4.1 项目部署

    我的Django项目部署情况:
    部署路径:
    /biao/hly_yw_project/
    即将logsquery.20200601.tar.gz 直接解压到/biao/hly_yw_project 目录。
    manage.py 文件路径:/biao/hly_yw_project/logsquery/manage.py
    wsgi.py 文件路径:/biao/hly_yw_project/logsquery/logsquery/wsgi.py
    settings.py 文件路径:/biao/hly_yw_project/logsquery/logsquery/settings.py
    查询出来的文件放到这里:
    /biao/hly_yw_project/logsquery/queryapp/static/files/
    目前只保留7天的文件:

    0 2 * * * find /biao/hly_yw_project/logsquery/queryapp/static/files -name "*.txt" -mtime +7 -type f |xargs rm -f
    

    项目结构是这样的:

     

    3.4.2 项目测试

    1、确保Django项目能够正常运行,即能够用Python3 manage.py runserver 0.0.0.0:8000 运行。

    (env1) [root@ansible-server2 logs]# cd /biao/hly_yw_project/logsquery/
    (env1) [root@ansible-server2 logs]# Python3 manage.py runserver 0.0.0.0:8000
    

    用浏览器访问ip:8000看下能否正常访问下面页面。

     

     

     

    四、nginx+uwsgi+Django代理项目

    4.1 安装uwsgi

    uwsgi是wsgi协议的实现服务。
    我是离线安装的。
    下载 uwsgi-2.0.18.tar.gz
    可以找一台能够联网的服务器通过pip download 命令来下载,传到离线服务器上面。
    解压安装:(在虚拟环境里面安装)

    workon env1
    tar zxf uwsgi-2.0.18.tar.gz
    cd uwsgi-2.0.18
    python3 setup.py build
    python3 setup.py install
    pip list 查看是否安装成功
    uWSGI 2.0.18

     

    4.2 配置uwsgi

    mkdir /etc/uwsgi_conf/
    cat /etc/uwsgi_conf/uwsgi.ini
    
    # uwsig使用配置文件启动
    [uwsgi]
    # 项目所在的根目录
    chdir=/biao/hly_yw_project/logsquery
    # 指定项目的application,区别于启动命令--wsgi-filemysite/wsgi.py
    #logsquery自己应用的名字
    module=logsquery.wsgi:application
    #the local unix socket file than commnuincate to Nginx
    # 指定sock的文件路径,这个sock文件会在nginx的uwsgi_pass配置,用来nginx与uwsgi通信
    # 支持ip+port模式以及socket file模式
    #socket=/etc/uwsgi_conf/uwsgi.sock
    socket=127.0.0.1:9050
    # 进程个数
    processes = 8
    # 每个进程worker数
    workers=5
    procname-prefix-spaced=queryapp # uwsgi的进程名称前缀
    py-autoreload=1 # py文件修改,自动加载
    # 指定IP端口,web访问入口
    http=0.0.0.0:9051
    # 启动uwsgi的用户名和用户组
    uid=root
    gid=root
    # 启用主进程
    master=true
    # 自动移除unix Socket和pid文件当服务停止的时候
    vacuum=true
    # 序列化接受的内容,如果可能的话
    thunder-lock=true
    # 启用线程
    enable-threads=true
    # 设置一个超时,用于中断那些超过服务器请求上限的额外请求
    harakiri=30
    # 设置缓冲
    post-buffering=4096
    # 设置日志目录
    daemonize=/var/log/uwsgi_conf/uwsgi.log
    # uWSGI进程号存放
    pidfile=/etc/uwsgi_conf/uwsgi.pid
    #monitor uwsgi status 通过该端口可以监控 uwsgi 的负载情况
    # 支持ip+port模式以及socket file模式
    # stats=%(chdir)/uwsgi_conf/uwsgi.status

     

    4.3 启动uwsgi

    cd /etc/uwsgi_conf/
    uwsgi --ini uwsgi.ini
    停止:
    uwsgi --stop uwsgi.pid

     

    4.4 配置nginx 代理Django

    nginx添加一个server:  

    server {
                listen       8000;
                server_name  xxxxxx;
                #注释下面配置,同时支持https和http访问
                #ssl on;
                #access_log  off;
                access_log /var/log/nginx/nginx.log;
                error_log /var/log/nginx/nginx.log;
                charset utf-8;
                client_max_body_size 100M;
                location /static{
                        alias /biao/hly_yw_project/logsquery/queryapp/static;
                }
                location /  {
                        include  /etc/nginx/uwsgi_params;
                        uwsgi_pass 0.0.0.0:9050;
                        proxy_read_timeout 3600s;
                        proxy_send_timeout 3600s;
                        uwsgi_read_timeout 600;
                        uwsgi_send_timeout 600;
                        uwsgi_connect_timeout 600;
                }
                error_page   500 502 503 504  /50x.html;
                location = /50x.html {
                    root   html;
                }
                #使用497状态重写到http上面
            }

    重启nginx或者重载nginx
    nginx -s reload
    页面访问:
    http://ip:8000即可访问Django项目

     

    五、Django3.0.7安装

    因1.8.2版本有漏洞,需要升级到最新版。最新版有些模块不兼容,代码也有些地方相对1.8.2的有改动。
    Django3.0的需要用这个包:
    xx.xx.x.xx: /biao/hly_yw_project/logsquery.django3.0.7.tar.gz
    其他应用安装方式不变,安装Django3.0.7方式。
    安装包备份目录:
    xx.x.xx.xx: /usr/local/vvm/logs/django
    xx.xx.xx.xx:/share/logs_bak/xx.xx.xx.xx/django
    进入虚拟环境:
    workon env1
    #解压
    tar zxf django3.0.tar.gz
    #安装
    pip install *whl
    其他配置参考1.8.2的

     

    展开全文
  • django日志

    2019-06-25 13:32:47
    django日志 日志框架的组成元素 logger: 日志系统的入口,可以配置 日志级别 Handlers 过滤器 Formatters 1.Loggers logger是日志的系统的入口,可以配置日志级别(日志级别:描述该logger处理的消息的严重性) ​ ...
  • Django的log,主要是复用Python标准库中的logging模块,在settings.py中进行配置 源代码 1、__init__.py包含以下类: StreamHandler Formatter %(name)s Name of the logger (logging channel) %...
  • 学习日志网站 基于Django 1.11开发 基于Django的学习日志系统 部署实列 加入网页功能测试 测试代码 测试结果
  • Django 日志

    2019-08-09 18:15:38
    Django使用Python内置的logging模块实现它自己的日志系统。 如果你没有使用过logging模块,请参考Python教程中的相关章节。 直达链接《logging模块详解》。 在Python的logging模块中,主要包含下面四大金刚: ...
  • django自定义日志系统

    2018-12-11 15:55:29
    当自定义后台系统中,需要自定义日志系统来记录操作操作日志 django提供了第三方插件来实现 pip install django-auditlog  在pip list中显示为: django-auditlog 将audit_log.middleware....
  • Django日志

    2019-03-21 18:55:38
    Django日志使用了python的logging模块,需要在settings中进行配置 logging模块由四部分组成 记录器 记录器配置具有日志级别。此日志级别描述了记录器将处理的消息的严重性。Python定义了以下日志级别: DEBUG: ...
  • Django日志系统

    2018-10-15 15:41:00
    日志在程序开发中是少不了...那么在django中是怎么处理日志django利用的就是Python提供的logging模块,但django中要用logging,还得有一定的配置规则,需要在setting中设置。下面简单介绍一下logging。 logging是...
  • Django 系统日志logging

    2019-10-04 14:45:10
    Django使用Python内建的logging模块去建造自己的系统日志的,如果你想详细了解这个模块的话,请自己去看python的说明文档,这里仅仅介绍Django中的日志系统。 日志配置包括四个部分:格式器(formatters),过滤器...
  • Django日志记录

    2018-12-07 09:22:59
    loggers 是日志系统的入口点,每一个日志都是一个以其命名的存储文件,日志信息经过处理后写入文件中 Handlers Filters Formatters loggers 设置的有五种日志级别,日志级别描述了将要处理的消息的严重性,级别如下...
  • django日志配置

    2021-03-30 17:55:18
    记录日志的方法有很多(轻易不要使用print),在django中,我们可以通过 import logging 直接使用Python内建的logging模块来实现. 理解logging 网上关于logging的资料有不少,大多也都是围绕官方文档来写的,我们...
  • Day084 django日志

    2019-11-01 12:32:11
    django日志 1、概述 ​ django框架的日志通过python内置的logging模块实现的,日记可以记录自定义的一些信息描述,也可以记录系统运行中的一些对象数据,还可以记录包括堆栈跟踪、错误代码之类的详细信息 ​ ...
  • Django日志处理

    千次阅读 2018-06-20 22:31:54
    日志处理 日志级别 DEBUG:用于调试目的的低级系统信息 INFO:一般系统信息 WARNING:描述发生的小问题的信息。...ERROR:描述发生的主要问题的信息。...CRITICAL:描述发生的关键问题的信息 ...Django...
  • Django日志配置

    2020-09-22 18:26:54
    日志用于记录或收集系统运行过程中的各种日志信息 日志 在项目配置文件中添加日志器配置 $ vim settings.py 日志一般位于项目根目录下的logs文件夹下,可通过手工创建,也可以在项目配置文件中使用项目自动...
  •   django框架的日志通过python内置的logging模块实现的,既可以记录自定义的一些信息描述,也可以记录系统运行中的一些对象数据,还可以记录包括堆栈跟踪、错误代码之类的详细信息。   logging主要由4部分组成:...
  • 主要介绍了django-捕获异常和日志系统过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • django的小课程项目 登陆注册 成功跳转到blog界面查看内容 应用django自带的数据库增删日志 很基础 分享给有需要的的人 代码都能运行 还有文档和截图
  • django:日志

    2021-06-01 20:49:11
    logger 是日志系统的入口。每个 logger 都是命名了的 bucket, 消息写入 bucket 以便进一步处理。 logger 可以配置 日志级别。日志级别描述了由该 logger 处理的消息的严重性。Python 定义了下面几种日志级别: DEBU
  • 基于邮件通知的服务监控和告警系统 主要功能点: 配置专用日志格式记录耗时 日志格式: 'simple':{ 'format':'%(asctimme)s %(message)s' } 处理器 'statistics_handler':{ 'level':'DEBUG', 'class':'logging...
  • 全栈工程师开发手册 (作者:栾鹏) python教程全解 ...django使用python内建的logging模块去建造自己的系统日志的,如果你想详细了解这个模块的话,请自己去看python的说明文档,这里仅仅介绍d...
  • 'django': { # 定义了一个名为django日志器 'handlers': ['console', 'file'], # 可以同时向终端与文件中输出日志 'propagate': True, # 是否继续传递日志信息 'level': 'INFO', # 日志器接收的最低日志级别 ...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 369
精华内容 147
关键字:

django日志系统