Logging API

Logger API. More...

Macros
#define	LOG_ERR(...)
	Writes an ERROR level message to the log.
#define	LOG_WRN(...)
	Writes a WARNING level message to the log.
#define	LOG_INF(...)
	Writes an INFO level message to the log.
#define	LOG_DBG(...)
	Writes a DEBUG level message to the log.
#define	LOG_WRN_ONCE(...)
	Writes a WARNING level message to the log on the first execution only.
#define	LOG_WRN_RATELIMIT(...)
	Writes a WARNING level message to the log with rate limiting.
#define	LOG_ERR_RATELIMIT(...)
	Writes an ERROR level message to the log with rate limiting.
#define	LOG_INF_RATELIMIT(...)
	Writes an INFO level message to the log with rate limiting.
#define	LOG_DBG_RATELIMIT(...)
	Writes a DEBUG level message to the log with rate limiting.
#define	LOG_HEXDUMP_ERR_RATELIMIT(_data, _length, _str)
	Writes an ERROR level hexdump message to the log with rate limiting.
#define	LOG_HEXDUMP_WRN_RATELIMIT(_data, _length, _str)
	Writes a WARNING level hexdump message to the log with rate limiting.
#define	LOG_HEXDUMP_INF_RATELIMIT(_data, _length, _str)
	Writes an INFO level hexdump message to the log with rate limiting.
#define	LOG_HEXDUMP_DBG_RATELIMIT(_data, _length, _str)
	Writes a DEBUG level hexdump message to the log with rate limiting.
#define	LOG_ERR_RATELIMIT_RATE(_rate_ms, ...)
	Rate-limited logging macros with custom rate.
#define	LOG_WRN_RATELIMIT_RATE(_rate_ms, ...)
	Writes a WARNING level message to the log with custom rate limiting.
#define	LOG_INF_RATELIMIT_RATE(_rate_ms, ...)
	Writes an INFO level message to the log with custom rate limiting.
#define	LOG_DBG_RATELIMIT_RATE(_rate_ms, ...)
	Writes a DEBUG level message to the log with custom rate limiting.
#define	LOG_HEXDUMP_ERR_RATELIMIT_RATE(_rate_ms, _data, _length, _str)
	Writes an ERROR level hexdump message to the log with custom rate limiting.
#define	LOG_HEXDUMP_WRN_RATELIMIT_RATE(_rate_ms, _data, _length, _str)
	Writes a WARNING level hexdump message to the log with custom rate limiting.
#define	LOG_HEXDUMP_INF_RATELIMIT_RATE(_rate_ms, _data, _length, _str)
	Writes an INFO level hexdump message to the log with custom rate limiting.
#define	LOG_HEXDUMP_DBG_RATELIMIT_RATE(_rate_ms, _data, _length, _str)
	Writes a DEBUG level hexdump message to the log with custom rate limiting.
#define	LOG_PRINTK(...)
	Unconditionally print raw log message.
#define	LOG_RAW(...)
	Unconditionally print raw log message.
#define	LOG_INST_ERR(_log_inst, ...)
	Writes an ERROR level message associated with the instance to the log.
#define	LOG_INST_WRN(_log_inst, ...)
	Writes a WARNING level message associated with the instance to the log.
#define	LOG_INST_INF(_log_inst, ...)
	Writes an INFO level message associated with the instance to the log.
#define	LOG_INST_DBG(_log_inst, ...)
	Writes a DEBUG level message associated with the instance to the log.
#define	LOG_HEXDUMP_ERR(_data, _length, _str)
	Writes an ERROR level hexdump message to the log.
#define	LOG_HEXDUMP_WRN(_data, _length, _str)
	Writes a WARNING level message to the log.
#define	LOG_HEXDUMP_INF(_data, _length, _str)
	Writes an INFO level message to the log.
#define	LOG_HEXDUMP_DBG(_data, _length, _str)
	Writes a DEBUG level message to the log.
#define	LOG_INST_HEXDUMP_ERR(_log_inst, _data, _length, _str)
	Writes an ERROR hexdump message associated with the instance to the log.
#define	LOG_INST_HEXDUMP_WRN(_log_inst, _data, _length, _str)
	Writes a WARNING level hexdump message associated with the instance to the log.
#define	LOG_INST_HEXDUMP_INF(_log_inst, _data, _length, _str)
	Writes an INFO level hexdump message associated with the instance to the log.
#define	LOG_INST_HEXDUMP_DBG(_log_inst, _data, _length, _str)
	Writes a DEBUG level hexdump message associated with the instance to the log.
#define	LOG_MODULE_REGISTER(...)
	Create module-specific state and register the module with Logger.
#define	LOG_MODULE_DECLARE(...)
	Macro for declaring a log module (not registering it).
#define	LOG_LEVEL_SET(level)
	Macro for setting log level in the file or function where instance logging API is used.

Detailed Description

Logger API.

Macro Definition Documentation

LOG_DBG

#define LOG_DBG

(

...

)

#include <zephyr/logging/log.h>

Value:

Z_LOG(LOG_LEVEL_DBG, __VA_ARGS__)

Writes a DEBUG level message to the log.

It's meant to write developer oriented information.

Parameters

...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_DBG_RATELIMIT

#define LOG_DBG_RATELIMIT

(

...

)

#include <zephyr/logging/log.h>

Value:

        _LOG_RATELIMIT_LVL(LOG_LEVEL_DBG, LOG_RATELIMIT_INTERVAL_MS, __VA_ARGS__)

Writes a DEBUG level message to the log with rate limiting.

It's meant to write developer oriented information with rate limiting to prevent log flooding. The message will be logged at most once per default interval (see CONFIG_LOG_RATELIMIT_INTERVAL_MS).

Parameters

...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_DBG_RATELIMIT_RATE

#define LOG_DBG_RATELIMIT_RATE	(		_rate_ms,
			... )

#include <zephyr/logging/log.h>

Value:

        _LOG_RATELIMIT_LVL(LOG_LEVEL_DBG, _rate_ms, __VA_ARGS__)

Writes a DEBUG level message to the log with custom rate limiting.

It's meant to write developer oriented information with rate limiting to prevent log flooding. The message will be logged at most once per specified interval.

Parameters

_rate_ms	Minimum interval in milliseconds between log messages.
...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_ERR

#define LOG_ERR

(

...

)

#include <zephyr/logging/log.h>

Value:

Z_LOG(LOG_LEVEL_ERR, __VA_ARGS__)

Writes an ERROR level message to the log.

It's meant to report severe errors, such as those from which it's not possible to recover.

Parameters

...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_ERR_RATELIMIT

#define LOG_ERR_RATELIMIT

(

...

)

#include <zephyr/logging/log.h>

Value:

        _LOG_RATELIMIT_LVL(LOG_LEVEL_ERR, LOG_RATELIMIT_INTERVAL_MS, __VA_ARGS__)

Writes an ERROR level message to the log with rate limiting.

It's meant to report severe errors, such as those from which it's not possible to recover, but with rate limiting to prevent log flooding. The message will be logged at most once per default interval (see CONFIG_LOG_RATELIMIT_INTERVAL_MS).

Parameters

...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_ERR_RATELIMIT_RATE

#define LOG_ERR_RATELIMIT_RATE	(		_rate_ms,
			... )

#include <zephyr/logging/log.h>

Value:

        _LOG_RATELIMIT_LVL(LOG_LEVEL_ERR, _rate_ms, __VA_ARGS__)

Rate-limited logging macros with custom rate.

These macros provide rate-limited logging functionality with custom rate intervals. They take an explicit rate parameter (in milliseconds) that specifies the minimum interval between log messages.

Writes an ERROR level message to the log with custom rate limiting.

It's meant to report severe errors, such as those from which it's not possible to recover, but with rate limiting to prevent log flooding. The message will be logged at most once per specified interval.

Parameters

_rate_ms	Minimum interval in milliseconds between log messages.
...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_HEXDUMP_DBG

#define LOG_HEXDUMP_DBG	(		_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

Z_LOG_HEXDUMP(LOG_LEVEL_DBG, _data, _length, (_str))

Writes a DEBUG level message to the log.

It's meant to write developer oriented information.

Parameters

_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_HEXDUMP_DBG_RATELIMIT

#define LOG_HEXDUMP_DBG_RATELIMIT	(		_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

        _LOG_HEXDUMP_RATELIMIT_LVL(LOG_LEVEL_DBG, LOG_RATELIMIT_INTERVAL_MS, _data, _length, _str)

Writes a DEBUG level hexdump message to the log with rate limiting.

It's meant to write developer oriented information with rate limiting to prevent log flooding. The message will be logged at most once per default interval (see CONFIG_LOG_RATELIMIT_INTERVAL_MS).

Parameters

_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_HEXDUMP_DBG_RATELIMIT_RATE

#define LOG_HEXDUMP_DBG_RATELIMIT_RATE	(		_rate_ms,
			_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

        _LOG_HEXDUMP_RATELIMIT_LVL(LOG_LEVEL_DBG, _rate_ms, _data, _length, _str)

Writes a DEBUG level hexdump message to the log with custom rate limiting.

It's meant to write developer oriented information with rate limiting to prevent log flooding. The message will be logged at most once per specified interval.

Parameters

_rate_ms	Minimum interval in milliseconds between log messages.
_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_HEXDUMP_ERR

#define LOG_HEXDUMP_ERR	(		_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

Z_LOG_HEXDUMP(LOG_LEVEL_ERR, _data, _length, (_str))

Writes an ERROR level hexdump message to the log.

It's meant to report severe errors, such as those from which it's not possible to recover.

Parameters

_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_HEXDUMP_ERR_RATELIMIT

#define LOG_HEXDUMP_ERR_RATELIMIT	(		_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

        _LOG_HEXDUMP_RATELIMIT_LVL(LOG_LEVEL_ERR, LOG_RATELIMIT_INTERVAL_MS, _data, _length, _str)

Writes an ERROR level hexdump message to the log with rate limiting.

It's meant to report severe errors, such as those from which it's not possible to recover, but with rate limiting to prevent log flooding. The message will be logged at most once per default interval (see CONFIG_LOG_RATELIMIT_INTERVAL_MS).

Parameters

_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_HEXDUMP_ERR_RATELIMIT_RATE

#define LOG_HEXDUMP_ERR_RATELIMIT_RATE	(		_rate_ms,
			_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

        _LOG_HEXDUMP_RATELIMIT_LVL(LOG_LEVEL_ERR, _rate_ms, _data, _length, _str)

Writes an ERROR level hexdump message to the log with custom rate limiting.

It's meant to report severe errors, such as those from which it's not possible to recover, but with rate limiting to prevent log flooding. The message will be logged at most once per specified interval.

Parameters

_rate_ms	Minimum interval in milliseconds between log messages.
_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_HEXDUMP_INF

#define LOG_HEXDUMP_INF	(		_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

Z_LOG_HEXDUMP(LOG_LEVEL_INF, _data, _length, (_str))

Writes an INFO level message to the log.

It's meant to write generic user oriented messages.

Parameters

_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_HEXDUMP_INF_RATELIMIT

#define LOG_HEXDUMP_INF_RATELIMIT	(		_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

        _LOG_HEXDUMP_RATELIMIT_LVL(LOG_LEVEL_INF, LOG_RATELIMIT_INTERVAL_MS, _data, _length, _str)

Writes an INFO level hexdump message to the log with rate limiting.

It's meant to write generic user oriented messages with rate limiting to prevent log flooding. The message will be logged at most once per default interval (see CONFIG_LOG_RATELIMIT_INTERVAL_MS).

Parameters

_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_HEXDUMP_INF_RATELIMIT_RATE

#define LOG_HEXDUMP_INF_RATELIMIT_RATE	(		_rate_ms,
			_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

        _LOG_HEXDUMP_RATELIMIT_LVL(LOG_LEVEL_INF, _rate_ms, _data, _length, _str)

Writes an INFO level hexdump message to the log with custom rate limiting.

It's meant to write generic user oriented messages with rate limiting to prevent log flooding. The message will be logged at most once per specified interval.

Parameters

_rate_ms	Minimum interval in milliseconds between log messages.
_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_HEXDUMP_WRN

#define LOG_HEXDUMP_WRN	(		_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

Z_LOG_HEXDUMP(LOG_LEVEL_WRN, _data, _length, (_str))

Writes a WARNING level message to the log.

It's meant to register messages related to unusual situations that are not necessarily errors.

Parameters

_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_HEXDUMP_WRN_RATELIMIT

#define LOG_HEXDUMP_WRN_RATELIMIT	(		_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

        _LOG_HEXDUMP_RATELIMIT_LVL(LOG_LEVEL_WRN, LOG_RATELIMIT_INTERVAL_MS, _data, _length, _str)

Writes a WARNING level hexdump message to the log with rate limiting.

It's meant to register messages related to unusual situations that are not necessarily errors, but with rate limiting to prevent log flooding. The message will be logged at most once per default interval (see CONFIG_LOG_RATELIMIT_INTERVAL_MS).

Parameters

_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_HEXDUMP_WRN_RATELIMIT_RATE

#define LOG_HEXDUMP_WRN_RATELIMIT_RATE	(		_rate_ms,
			_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

        _LOG_HEXDUMP_RATELIMIT_LVL(LOG_LEVEL_WRN, _rate_ms, _data, _length, _str)

Writes a WARNING level hexdump message to the log with custom rate limiting.

It's meant to register messages related to unusual situations that are not necessarily errors, but with rate limiting to prevent log flooding. The message will be logged at most once per specified interval.

Parameters

_rate_ms	Minimum interval in milliseconds between log messages.
_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_INF

#define LOG_INF

(

...

)

#include <zephyr/logging/log.h>

Value:

Z_LOG(LOG_LEVEL_INF, __VA_ARGS__)

Writes an INFO level message to the log.

It's meant to write generic user oriented messages.

Parameters

...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_INF_RATELIMIT

#define LOG_INF_RATELIMIT

(

...

)

#include <zephyr/logging/log.h>

Value:

        _LOG_RATELIMIT_LVL(LOG_LEVEL_INF, LOG_RATELIMIT_INTERVAL_MS, __VA_ARGS__)

Writes an INFO level message to the log with rate limiting.

It's meant to write generic user oriented messages with rate limiting to prevent log flooding. The message will be logged at most once per default interval (see CONFIG_LOG_RATELIMIT_INTERVAL_MS).

Parameters

...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_INF_RATELIMIT_RATE

#define LOG_INF_RATELIMIT_RATE	(		_rate_ms,
			... )

#include <zephyr/logging/log.h>

Value:

        _LOG_RATELIMIT_LVL(LOG_LEVEL_INF, _rate_ms, __VA_ARGS__)

Writes an INFO level message to the log with custom rate limiting.

It's meant to write generic user oriented messages with rate limiting to prevent log flooding. The message will be logged at most once per specified interval.

Parameters

_rate_ms	Minimum interval in milliseconds between log messages.
...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_INST_DBG

#define LOG_INST_DBG	(		_log_inst,
			... )

#include <zephyr/logging/log.h>

Value:

Z_LOG_INSTANCE(LOG_LEVEL_DBG, _log_inst, __VA_ARGS__)

Writes a DEBUG level message associated with the instance to the log.

Message is associated with specific instance of the module which has independent filtering settings (if runtime filtering is enabled) and message prefix (<module_name>.<instance_name>). It's meant to write developer oriented information.

Parameters

_log_inst	Pointer to the log structure associated with the instance.
...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_INST_ERR

#define LOG_INST_ERR	(		_log_inst,
			... )

#include <zephyr/logging/log.h>

Value:

Z_LOG_INSTANCE(LOG_LEVEL_ERR, _log_inst, __VA_ARGS__)

Writes an ERROR level message associated with the instance to the log.

Message is associated with specific instance of the module which has independent filtering settings (if runtime filtering is enabled) and message prefix (<module_name>.<instance_name>). It's meant to report severe errors, such as those from which it's not possible to recover.

Parameters

_log_inst	Pointer to the log structure associated with the instance.
...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_INST_HEXDUMP_DBG

#define LOG_INST_HEXDUMP_DBG	(		_log_inst,
			_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

        Z_LOG_HEXDUMP_INSTANCE(LOG_LEVEL_DBG, _log_inst, _data, _length, _str)

Writes a DEBUG level hexdump message associated with the instance to the log.

It's meant to write developer oriented information.

Parameters

_log_inst	Pointer to the log structure associated with the instance.
_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_INST_HEXDUMP_ERR

#define LOG_INST_HEXDUMP_ERR	(		_log_inst,
			_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

        Z_LOG_HEXDUMP_INSTANCE(LOG_LEVEL_ERR, _log_inst, _data, _length, _str)

Writes an ERROR hexdump message associated with the instance to the log.

Message is associated with specific instance of the module which has independent filtering settings (if runtime filtering is enabled) and message prefix (<module_name>.<instance_name>). It's meant to report severe errors, such as those from which it's not possible to recover.

Parameters

_log_inst	Pointer to the log structure associated with the instance.
_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_INST_HEXDUMP_INF

#define LOG_INST_HEXDUMP_INF	(		_log_inst,
			_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

        Z_LOG_HEXDUMP_INSTANCE(LOG_LEVEL_INF, _log_inst, _data, _length, _str)

Writes an INFO level hexdump message associated with the instance to the log.

It's meant to write generic user oriented messages.

Parameters

_log_inst	Pointer to the log structure associated with the instance.
_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_INST_HEXDUMP_WRN

#define LOG_INST_HEXDUMP_WRN	(		_log_inst,
			_data,
			_length,
			_str )

#include <zephyr/logging/log.h>

Value:

        Z_LOG_HEXDUMP_INSTANCE(LOG_LEVEL_WRN, _log_inst, _data, _length, _str)

Writes a WARNING level hexdump message associated with the instance to the log.

It's meant to register messages related to unusual situations that are not necessarily errors.

Parameters

_log_inst	Pointer to the log structure associated with the instance.
_data	Pointer to the data to be logged.
_length	Length of data (in bytes).
_str	Persistent, raw string.

LOG_INST_INF

#define LOG_INST_INF	(		_log_inst,
			... )

#include <zephyr/logging/log.h>

Value:

Z_LOG_INSTANCE(LOG_LEVEL_INF, _log_inst, __VA_ARGS__)

Writes an INFO level message associated with the instance to the log.

Message is associated with specific instance of the module which has independent filtering settings (if runtime filtering is enabled) and message prefix (<module_name>.<instance_name>). It's meant to write generic user oriented messages.

Parameters

_log_inst	Pointer to the log structure associated with the instance.
...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_INST_WRN

#define LOG_INST_WRN	(		_log_inst,
			... )

#include <zephyr/logging/log.h>

Value:

Z_LOG_INSTANCE(LOG_LEVEL_WRN, _log_inst, __VA_ARGS__)

Writes a WARNING level message associated with the instance to the log.

Message is associated with specific instance of the module which has independent filtering settings (if runtime filtering is enabled) and message prefix (<module_name>.<instance_name>). It's meant to register messages related to unusual situations that are not necessarily errors.

Parameters

_log_inst	Pointer to the log structure associated with the instance.
...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_LEVEL_SET

#define LOG_LEVEL_SET

(

level

)

#include <zephyr/logging/log.h>

Value:

        static const uint32_t __log_level __unused = Z_LOG_RESOLVED_LEVEL(level, 0)

Macro for setting log level in the file or function where instance logging API is used.

Parameters

level

Level used in file or in function.

LOG_MODULE_DECLARE

#define LOG_MODULE_DECLARE

(

...

)

#include <zephyr/logging/log.h>

Value:

        extern const struct log_source_const_data Z_LOG_ITEM_CONST_DATA(                           \
                GET_ARG_N(1, __VA_ARGS__));                                                        \
        extern struct log_source_dynamic_data LOG_ITEM_DYNAMIC_DATA(GET_ARG_N(1, __VA_ARGS__));    \
                                                                                                   \
        Z_LOG_MODULE_PARTITION(K_APP_DMEM)                                                         \
        static const struct log_source_const_data *__log_current_const_data __unused =             \
                Z_DO_LOG_MODULE_REGISTER(__VA_ARGS__)                                              \
                        ? &Z_LOG_ITEM_CONST_DATA(GET_ARG_N(1, __VA_ARGS__))                        \
                        : NULL;                                                                    \
                                                                                                   \
        Z_LOG_MODULE_PARTITION(K_APP_DMEM)                                                         \
        static struct log_source_dynamic_data *__log_current_dynamic_data __unused =               \
                (Z_DO_LOG_MODULE_REGISTER(__VA_ARGS__) &&                                          \
                 IS_ENABLED(CONFIG_LOG_RUNTIME_FILTERING))                                         \
                        ? &LOG_ITEM_DYNAMIC_DATA(GET_ARG_N(1, __VA_ARGS__))                        \
                        : NULL;                                                                    \
                                                                                                   \
        Z_LOG_MODULE_PARTITION(K_APP_BMEM)                                                         \
        static const uint32_t __log_level __unused = _LOG_LEVEL_RESOLVE(__VA_ARGS__)

Macro for declaring a log module (not registering it).

Modules which are split up over multiple files must have exactly one file use LOG_MODULE_REGISTER() to create module-specific state and register the module with the logger core.

The other files in the module should use this macro instead to declare that same state. (Otherwise, LOG_INF() etc. will not be able to refer to module-specific state variables.)

Macro accepts one or two parameters:

• module name
• optional log level. If not provided then default log level is used in the file.

Example usage:

• LOG_MODULE_DECLARE(foo, CONFIG_FOO_LOG_LEVEL)
• LOG_MODULE_DECLARE(foo)

Note

The module's state is declared only if LOG_LEVEL for the current source file is non-zero or it is not defined and CONFIG_LOG_DEFAULT_LEVEL is non-zero. In other cases, this macro has no effect.

See also

LOG_MODULE_REGISTER

LOG_MODULE_REGISTER

#define LOG_MODULE_REGISTER

(

...

)

#include <zephyr/logging/log.h>

Value:

        COND_CODE_1(                                                 \
                Z_DO_LOG_MODULE_REGISTER(__VA_ARGS__),                  \
                (_LOG_MODULE_DATA_CREATE(GET_ARG_N(1, __VA_ARGS__),    \
                                      _LOG_LEVEL_RESOLVE(__VA_ARGS__))),\
                () \
        )                                                                       \
        LOG_MODULE_DECLARE(__VA_ARGS__)

Create module-specific state and register the module with Logger.

This macro normally must be used after including <zephyr/logging/log.h> to complete the initialization of the module.

Module registration can be skipped in two cases:

• The module consists of more than one file, and another file invokes this macro. (LOG_MODULE_DECLARE() should be used instead in all of the module's other files.)
• Instance logging is used and there is no need to create module entry. In that case LOG_LEVEL_SET() should be used to set log level used within the file.

Macro accepts one or two parameters:

• module name
• optional log level. If not provided then default log level is used in the file.

Example usage:

• LOG_MODULE_REGISTER(foo, CONFIG_FOO_LOG_LEVEL)
• LOG_MODULE_REGISTER(foo)

Note

The module's state is defined, and the module is registered, only if LOG_LEVEL for the current source file is non-zero or it is not defined and CONFIG_LOG_DEFAULT_LEVEL is non-zero. In other cases, this macro has no effect.

See also

LOG_MODULE_DECLARE

LOG_PRINTK

#define LOG_PRINTK

(

...

)

#include <zephyr/logging/log.h>

Value:

Z_LOG_PRINTK(0, __VA_ARGS__)

Unconditionally print raw log message.

The result is same as if printk was used but it goes through logging infrastructure thus utilizes logging mode, e.g. deferred mode.

Parameters

...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_RAW

#define LOG_RAW

(

...

)

#include <zephyr/logging/log.h>

Value:

Z_LOG_PRINTK(1, __VA_ARGS__)

Unconditionally print raw log message.

Provided string is printed as is without appending any characters (e.g., color or newline).

Parameters

...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_WRN

#define LOG_WRN

(

...

)

#include <zephyr/logging/log.h>

Value:

Z_LOG(LOG_LEVEL_WRN, __VA_ARGS__)

Writes a WARNING level message to the log.

It's meant to register messages related to unusual situations that are not necessarily errors.

Parameters

...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_WRN_ONCE

#define LOG_WRN_ONCE

(

...

)

#include <zephyr/logging/log.h>

Value:

        do {                                                                                       \
                static atomic_t __warned;                                                          \
                if (unlikely(atomic_cas(&__warned, 0, 1))) {                                       \
                        Z_LOG(LOG_LEVEL_WRN, __VA_ARGS__);                                         \
                }                                                                                  \
        } while (0)

Writes a WARNING level message to the log on the first execution only.

It's meant for situations that warrant investigation but could clutter the logs if output on every execution.

Parameters

...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_WRN_RATELIMIT

#define LOG_WRN_RATELIMIT

(

...

)

#include <zephyr/logging/log.h>

Value:

        _LOG_RATELIMIT_LVL(LOG_LEVEL_WRN, LOG_RATELIMIT_INTERVAL_MS, __VA_ARGS__)

Writes a WARNING level message to the log with rate limiting.

It's meant for situations that warrant investigation but could clutter the logs if output too frequently. The message will be logged at most once per default interval (see CONFIG_LOG_RATELIMIT_INTERVAL_MS).

Parameters

...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.

LOG_WRN_RATELIMIT_RATE

#define LOG_WRN_RATELIMIT_RATE	(		_rate_ms,
			... )

#include <zephyr/logging/log.h>

Value:

        _LOG_RATELIMIT_LVL(LOG_LEVEL_WRN, _rate_ms, __VA_ARGS__)

Writes a WARNING level message to the log with custom rate limiting.

It's meant for situations that warrant investigation but could clutter the logs if output too frequently. The message will be logged at most once per specified interval.

Parameters

_rate_ms	Minimum interval in milliseconds between log messages.
...	A string optionally containing printk valid conversion specifier, followed by as many values as specifiers.