Logs a message with level :const:`DEBUG` on the root logger. The *msg* is the

message format string, and the *args* are the arguments which are merged into

*msg* using the string formatting operator. (Note that this means that you can

use keywords in the format string, together with a single dictionary argument.)

There are three keyword arguments in *kwargs* which are inspected: *exc_info*

which, if it does not evaluate as false, causes exception information to be

added to the logging message. If an exception tuple (in the format returned by

:func:`sys.exc_info`) or an exception instance is provided, it is used;

otherwise, :func:`sys.exc_info` is called to get the exception information.

The second optional keyword argument is *stack_info*, which defaults to

``False``. If true, stack information is added to the logging

message, including the actual logging call. Note that this is not the same

stack information as that displayed through specifying *exc_info*: The

former is stack frames from the bottom of the stack up to the logging call

in the current thread, whereas the latter is information about stack frames

which have been unwound, following an exception, while searching for

exception handlers.

You can specify *stack_info* independently of *exc_info*, e.g. to just show

how you got to a certain point in your code, even when no exceptions were

raised. The stack frames are printed following a header line which says:

.. code-block:: none

This mimics the ``Traceback (most recent call last):`` which is used when

displaying exception frames.

The third optional keyword argument is *extra* which can be used to pass a

dictionary which is used to populate the __dict__ of the LogRecord created for

the logging event with user-defined attributes. These custom attributes can then

be used as you like. For example, they could be incorporated into logged

messages. For example::

would print something like:

.. code-block:: none

The keys in the dictionary passed in *extra* should not clash with the keys used

by the logging system. (See the :class:`Formatter` documentation for more

information on which keys are used by the logging system.)

If you choose to use these attributes in logged messages, you need to exercise

some care. In the above example, for instance, the :class:`Formatter` has been

set up with a format string which expects 'clientip' and 'user' in the attribute

dictionary of the LogRecord. If these are missing, the message will not be

logged because a string formatting exception will occur. So in this case, you

always need to pass the *extra* dictionary with these keys.

While this might be annoying, this feature is intended for use in specialized

circumstances, such as multi-threaded servers where the same code executes in

many contexts, and interesting conditions which arise are dependent on this

context (such as remote client IP address and authenticated user name, in the

above example). In such circumstances, it is likely that specialized

:class:`Formatter`\ s would be used with particular :class:`Handler`\ s.

This function (as well as :func:`info`, :func:`warning`, :func:`error` and

:func:`critical`) will call :func:`basicConfig` if the root logger doesn't

have any handler attached.

.. versionchanged:: 3.2

The *stack_info* parameter was added.

Logs a message with level :const:`INFO` on the root logger. The arguments are

interpreted as for :func:`debug`.

Logs a message with level :const:`WARNING` on the root logger. The arguments

are interpreted as for :func:`debug`.

Logs a message with level :const:`ERROR` on the root logger. The arguments are

interpreted as for :func:`debug`.

Logs a message with level :const:`CRITICAL` on the root logger. The arguments

are interpreted as for :func:`debug`.

Logs a message with level :const:`ERROR` on the root logger. The arguments are

interpreted as for :func:`debug`. Exception info is added to the logging

Logs a message with level *level* on the root logger. The other arguments are

interpreted as for :func:`debug`.