Python settings.LOGGING屬性代碼示例

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def setup(set_prefix=True):
    """
    Configure the settings (this happens as a side effect of accessing the
    first setting), configure logging and populate the app registry.
    Set the thread-local urlresolvers script prefix if `set_prefix` is True.
    """
    from django.apps import apps
    from django.conf import settings
    from django.urls import set_script_prefix
    from django.utils.log import configure_logging

    configure_logging(settings.LOGGING_CONFIG, settings.LOGGING)
    if set_prefix:
        set_script_prefix(
            '/' if settings.FORCE_SCRIPT_NAME is None else settings.FORCE_SCRIPT_NAME
        )
    apps.populate(settings.INSTALLED_APPS) 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def get_string_db_logger():
    """
    Gets you what you need to log to a string. Returns a pair of StringIO, logger variables.
    >>> output, logger = get_string_db_logger()
    >>> call_stuff_to_debug_with_logger(logger=logger)
    >>> print output.getvalue()
    """
    logger = logging.getLogger('django.db.backends')
    logger.setLevel(logging.DEBUG)
    try:
        fmt = settings.LOGGING['formatters']['verbose']['format']
    except KeyError:
        fmt = "%(levelname)-7s %(asctime)s | %(message)s"
    formatter = logging.Formatter(fmt)
    output = StringIO()
    string_handler = logging.StreamHandler(output)
    string_handler.setFormatter(formatter)
    string_handler.setLevel(logging.DEBUG)
    logger.addHandler(string_handler)

    return output, logger 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def setup(set_prefix=True):
    """
    Configure the settings (this happens as a side effect of accessing the
    first setting), configure logging and populate the app registry.
    Set the thread-local urlresolvers script prefix if `set_prefix` is True.
    """
    from django.apps import apps
    from django.conf import settings
    from django.urls import set_script_prefix
    from django.utils.encoding import force_text
    from django.utils.log import configure_logging

    configure_logging(settings.LOGGING_CONFIG, settings.LOGGING)
    if set_prefix:
        set_script_prefix(
            '/' if settings.FORCE_SCRIPT_NAME is None else force_text(settings.FORCE_SCRIPT_NAME)
        )
    apps.populate(settings.INSTALLED_APPS) 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def handle(self, *args, **options):
    with Mainframe() as mainframe:
      uname = platform.uname()
      with open(settings.LOGGING['handlers']['file']['filename'], 'r') as log:
        traceback = self.tail(log, 100)

      payload = {
          'path': sys.path,
          'version': platform.python_version(),
          'system': {x: uname.__getattribute__(x) for x in uname._fields},
          'distro': '-'.join(platform.linux_distribution()),
          'log': traceback,
          'directory': settings.BASE_DIR
      }
      response = requests.put("https://{}/api/v1/instance/{}/report".format(
                              settings.MAINFRAME, mainframe().id),
                              json=payload)

      identifier = response.json()['result']['id']

      self.stdout.write(self.style.SUCCESS("""
        When talking to the maintainer indietyp,
        please use this ID to identify your ticket:"""))
      self.stdout.write(identifier) 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def setUp(self):
        logging_conf = """
[loggers]
keys=root
[handlers]
keys=stream
[formatters]
keys=simple
[logger_root]
handlers=stream
[handler_stream]
class=StreamHandler
formatter=simple
args=(sys.stdout,)
[formatter_simple]
format=%(message)s
"""
        self.temp_file = NamedTemporaryFile()
        self.temp_file.write(logging_conf.encode())
        self.temp_file.flush()
        sdict = {'LOGGING_CONFIG': '"logging.config.fileConfig"',
                 'LOGGING': 'r"%s"' % self.temp_file.name}
        self.write_settings('settings.py', sdict=sdict) 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def setup():
    """
    Configure the settings (this happens as a side effect of accessing the
    first setting), configure logging and populate the app registry.
    """
    from django.apps import apps
    from django.conf import settings
    from django.utils.log import configure_logging

    configure_logging(settings.LOGGING_CONFIG, settings.LOGGING)
    apps.populate(settings.INSTALLED_APPS) 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def configure_logger(conf=None, **kwargs):
    from django.conf import settings
    configure_logging(settings.LOGGING_CONFIG, settings.LOGGING) 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def get_warn_log(request):
    warn_log_file = settings.LOGGING['handlers']['my_warn']['filename']
    logs = list(reversed(open(warn_log_file).read().split('\n')))[:500]

    logs = [l for l in logs if l]

    context = dict()
    context['logs'] = logs

    return render(request, 'dashboard/logs.html', context=context) 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def config_loggers(*args, **kwargs):
    dictConfig(settings.LOGGING) 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def config_loggers(*args, **kwags):
    dictConfig(settings.LOGGING)

# example task that is passed info about itself 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def setUpClass(cls):
        super().setUpClass()
        cls._logging = settings.LOGGING
        logging.config.dictConfig(DEFAULT_LOGGING) 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def setUp(self):
        log_config = """{
    'version': 1,
    'handlers': {
        'custom_handler': {
            'level': 'INFO',
            'class': 'logging_tests.logconfig.MyHandler',
        }
    }
}"""
        self.write_settings('settings.py', sdict={'LOGGING': log_config}) 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def reload_django_settings():
        mod = util.import_module(os.environ['DJANGO_SETTINGS_MODULE'])

        # Reload module.
        reload(mod)

        # Reload settings.
        # Use code from django.settings.Settings module.

        # Settings that should be converted into tuples if they're mistakenly entered
        # as strings.
        tuple_settings = ("INSTALLED_APPS", "TEMPLATE_DIRS")

        for setting in dir(mod):
            if setting == setting.upper():
                setting_value = getattr(mod, setting)
                if setting in tuple_settings and type(setting_value) == str:
                    setting_value = (setting_value,)  # In case the user forgot the comma.
                setattr(settings, setting, setting_value)

        # Expand entries in INSTALLED_APPS like "django.contrib.*" to a list
        # of all those apps.
        new_installed_apps = []
        for app in settings.INSTALLED_APPS:
            if app.endswith('.*'):
                app_mod = util.import_module(app[:-2])
                appdir = os.path.dirname(app_mod.__file__)
                app_subdirs = os.listdir(appdir)
                name_pattern = re.compile(r'[a-zA-Z]\w*')
                for d in sorted(app_subdirs):
                    if (name_pattern.match(d) and
                            os.path.isdir(os.path.join(appdir, d))):
                        new_installed_apps.append('%s.%s' % (app[:-2], d))
            else:
                new_installed_apps.append(app)
        setattr(settings, "INSTALLED_APPS", new_installed_apps)

        if hasattr(time, 'tzset') and settings.TIME_ZONE:
            # When we can, attempt to validate the timezone. If we can't find
            # this file, no check happens and it's harmless.
            zoneinfo_root = '/usr/share/zoneinfo'
            if (os.path.exists(zoneinfo_root) and not
                    os.path.exists(os.path.join(zoneinfo_root,
                        *(settings.TIME_ZONE.split('/'))))):
                raise ValueError("Incorrect timezone setting: %s" %
                        settings.TIME_ZONE)
            # Move the time zone info into os.environ. See ticket #2315 for why
            # we don't do this unconditionally (breaks Windows).
            os.environ['TZ'] = settings.TIME_ZONE
            time.tzset()

        # Settings are configured, so we can set up the logger if required
        if getattr(settings, 'LOGGING_CONFIG', False):
            # First find the logging configuration function ...
            logging_config_path, logging_config_func_name = settings.LOGGING_CONFIG.rsplit('.', 1)
            logging_config_module = util.import_module(logging_config_path)
            logging_config_func = getattr(logging_config_module, logging_config_func_name)

            # ... then invoke it with the logging settings
            logging_config_func(settings.LOGGING) 

# 需要導入模塊: from django.conf import settings [as 別名]
# 或者: from django.conf.settings import LOGGING [as 別名]
def reset_loggers_level():
    """
    Reset loggers' level from AppVar
    """

    def getEffectiveLevel(self):
        """
        Get the effective level for this logger.

        Loop through this logger and its parents in the logger hierarchy,
        looking for a non-zero logging level. Return the first one found.
        """
        logger = self

        # custom logic
        # cannot use AppVar due to circular import issue
        app_var_level = redis.pop(f'app_var:Logging:logger:{logger.name}:log_level')
        if app_var_level:
            app_var_level = app_var_level.upper()
            if app_var_level in logging._levelToName.values():
                logger.setLevel(app_var_level)

                # log sql to console
                if logger.name == 'django.db.backends':
                    handler = logging.StreamHandler()
                    handler.setLevel(logger.level)
                    logger_handler_classes = [i.__class__ for i in logger.handlers]
                    if redis.pop(f'app_var:Logging:logger:{logger.name}:log_to_console') is True:
                        if handler.__class__ not in logger_handler_classes:
                            logger.addHandler(handler)
                    else:
                        logger.handlers = [i for i in logger.handlers if i.__class__ != handler.__class__]
        # end custom logic

        while logger:
            if logger.level:
                return logger.level
            logger = logger.parent
        return logging.NOTSET

    # reset Project loggers
    for logger_name in settings.LOGGING['loggers']:
        logger = logging.getLogger(logger_name)
        logger.getEffectiveLevel = types.MethodType(getEffectiveLevel, logger)

    # reset celery loggers
    for logger_name in celery_logger_names:
        logger = get_logger(logger_name)
        logger.getEffectiveLevel = types.MethodType(getEffectiveLevel, logger)