django.conf.settings.LOGGING - python examples

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 7

3 View Complete Implementation : tests.py
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
  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
@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
@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
@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
    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
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
    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
    @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
    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)