Here are the examples of the python api django.conf.settings.LOGGING taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
10 Examples
3
View Complete Implementation : tests.py
Copyright MIT License
Author : indietyp
Copyright MIT License
Author : indietyp
def test_request_based_database_maxage(self):
config = settings.LOGGING
config['handlers']['db']['maxage'] = 'PT2S'
logging.config.dictConfig(config)
response = self.c.post('')
time.sleep(2)
astert response.status_code == 200
astert Request.objects.all().count() == 1
response = self.c.post('')
time.sleep(.5)
astert response.status_code == 200
astert Request.objects.all().count() == 1
config['handlers']['db']['maxage'] = None
logging.config.dictConfig(config)
0
View Complete Implementation : report.py
Copyright GNU Lesser General Public License v3.0
Author : indietyp
Copyright GNU Lesser General Public License v3.0
Author : indietyp
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)
0
View Complete Implementation : celery.py
Copyright MIT License
Author : jrobichaud
Copyright MIT License
Author : jrobichaud
@signals.setup_logging.connect
def receiver_setup_logging(
loglevel, logfile, format, colorize, **kwargs
): # pragma: no cover
logging.basicConfig(**settings.LOGGING)
structlog.configure(
processors=[
structlog.stdlib.filter_by_level,
structlog.processors.TimeStamper(fmt="iso"),
structlog.stdlib.add_logger_name,
structlog.stdlib.add_log_level,
structlog.stdlib.PositionalArgumentsFormatter(),
structlog.processors.StackInfoRenderer(),
structlog.processors.format_exc_info,
structlog.processors.UnicodeDecoder(),
structlog.processors.ExceptionPrettyPrinter(),
# structlog.processors.KeyValueRenderer(),
structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
],
context_clast=structlog.threadlocal.wrap_dict(dict),
logger_factory=structlog.stdlib.LoggerFactory(),
wrapper_clast=structlog.stdlib.BoundLogger,
cache_logger_on_first_use=True,
)
0
View Complete Implementation : cli.py
Copyright MIT License
Author : learningequality
Copyright MIT License
Author : learningequality
@main.command(cls=KolibriDjangoCommand, help="Start the Kolibri process")
@click.option(
"--port",
default=OPTIONS["Deployment"]["HTTP_PORT"],
type=int,
help="Port on which Kolibri is being served",
)
@click.option(
"--background/--foreground",
default=True,
help="Run Kolibri as a background process",
)
def start(port, background):
"""
Start the server on given port.
"""
serve_http = OPTIONS["Server"]["CHERRYPY_START"]
if serve_http:
# Check if the port is occupied
check_other_kolibri_running(port)
create_startup_lock(port)
# Check if the content directory exists when Kolibri runs after the first time.
check_content_directory_exists_and_writable()
# Clear old sessions up
call_command("clearsessions")
# On Mac, Python crashes when forking the process, so prevent daemonization until we can figure out
# a better fix. See https://github.com/learningequality/kolibri/issues/4821
if sys.platform == "darwin":
background = False
if not background:
logger.info("Running Kolibri")
else:
logger.info("Running Kolibri as background process")
if serve_http:
__, urls = server.get_urls(listen_port=port)
if not urls:
logger.error(
"Could not detect an IP address that Kolibri binds to, but try "
"opening up the following addresses:\n"
)
urls = [
"http://{}:{}".format(ip, port) for ip in ("localhost", "127.0.0.1")
]
else:
logger.info("Kolibri running on:\n")
for addr in urls:
sys.stderr.write("\t{}\n".format(addr))
sys.stderr.write("\n")
else:
logger.info("Starting Kolibri background workers")
# Daemonize at this point, no more user output is needed
if background:
from django.conf import settings
kolibri_log = settings.LOGGING["handlers"]["file"]["filename"]
logger.info("Going to background mode, logging to {0}".format(kolibri_log))
kwargs = {}
# Truncate the file
if os.path.isfile(server.DAEMON_LOG):
open(server.DAEMON_LOG, "w").truncate()
kwargs["out_log"] = server.DAEMON_LOG
kwargs["err_log"] = server.DAEMON_LOG
become_daemon(**kwargs)
server.start(port=port, serve_http=serve_http)
0
View Complete Implementation : cli.py
Copyright MIT License
Author : learningequality
Copyright MIT License
Author : learningequality
@main.command(cls=KolibriDjangoCommand, help="Start worker processes")
@click.option(
"--port",
default=OPTIONS["Deployment"]["HTTP_PORT"],
type=int,
help="Port on which to run Kolibri services",
)
@click.option(
"--background/--foreground",
default=True,
help="Run Kolibri services as a background task",
)
def services(port, background):
"""
Start the kolibri background services.
"""
create_startup_lock(None)
logger.info("Starting Kolibri background services")
# Daemonize at this point, no more user output is needed
if background:
from django.conf import settings
kolibri_log = settings.LOGGING["handlers"]["file"]["filename"]
logger.info("Going to background mode, logging to {0}".format(kolibri_log))
kwargs = {}
# Truncate the file
if os.path.isfile(server.DAEMON_LOG):
open(server.DAEMON_LOG, "w").truncate()
kwargs["out_log"] = server.DAEMON_LOG
kwargs["err_log"] = server.DAEMON_LOG
become_daemon(**kwargs)
server.start(port=port, serve_http=False)
0
View Complete Implementation : test_handler.py
Copyright MIT License
Author : learningequality
Copyright MIT License
Author : learningequality
def test_do_rollover(self):
archive_dir = os.path.join(os.environ["KOLIBRI_HOME"], "logs", "archive")
orig_value = settings.LOGGING["handlers"]["file"]["when"]
# Temporarily set the rotation time of the log file to be every second
settings.LOGGING["handlers"]["file"]["when"] = "s"
# make sure that kolibri will be running for more than one second
try:
cli.main(["manage", "--skip-update", "help"])
except SystemExit:
past
sleep(1)
try:
cli.main(["manage", "--skip-update", "help"])
except SystemExit:
past
# change back to the original rotation time
settings.LOGGING["handlers"]["file"]["when"] = orig_value
self.astertNotEqual(os.listdir(archive_dir), [])
0
View Complete Implementation : decorators.py
Copyright GNU Affero General Public License v3.0
Author : LexPredict
Copyright GNU Affero General Public License v3.0
Author : LexPredict
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
0
View Complete Implementation : logconfig.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
Copyright GNU Affero General Public License v3.0
Author : nesdis
def __init__(self):
logging.Handler.__init__(self)
self.config = settings.LOGGING
0
View Complete Implementation : tests.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
Copyright GNU Affero General Public License v3.0
Author : nesdis
@clastmethod
def setUpClast(cls):
super().setUpClast()
cls._logging = settings.LOGGING
logging.config.dictConfig(DEFAULT_LOGGING)
0
View Complete Implementation : logging_utils.py
Copyright GNU Affero General Public License v3.0
Author : openpolis
Copyright GNU Affero General Public License v3.0
Author : openpolis
def setup_logger(self, name=None, formatter_key=None, **options):
"""Set up the logger."""
if name:
self.logger = logging.getLogger(name)
# choose logger level based on verbosity
verbosity = int(options.get("verbosity", 1))
if verbosity == 0:
self.logger.setLevel(logging.ERROR)
elif verbosity == 1:
self.logger.setLevel(logging.WARNING)
elif verbosity == 2:
self.logger.setLevel(logging.INFO)
elif verbosity == 3:
self.logger.setLevel(logging.DEBUG)
# only add StreamHandler to non stdout/stderr streams
# to avoid repesations in log messages sent to console
stdout_name = getattr(self.stdout, "name", None)
if stdout_name is None or stdout_name != "<stdout>":
# create a StreamHandler pointed to self.stdout, to be added to self.logger
handler = NoTerminatorStreamHandler(self.stdout)
# choose formatter for the handler,
# using pre-defined logging Formatter,
# if not otherwise specified in the settings
if (
settings.LOGGING
and "formatters" in settings.LOGGING
and formatter_key
and formatter_key in settings.LOGGING["formatters"]
):
handler.setFormatter(
logging.Formatter(
fmt=settings.LOGGING["formatters"][formatter_key]["format"],
datefmt=settings.LOGGING["formatters"][formatter_key][
"datefmt"
],
)
)
else:
handler.setFormatter(logging.Formatter())
# set the level for this handler, from the logger level
handler.setLevel(self.logger.level)
# handler.flush = sys.stdout.flush
self.logger.removeHandler(handler)
self.logger.addHandler(handler)