Skip to content

Логирование

Logging.

Logger

Logger - Logging class, used by all components.

Example

from qtasks import QueueTasks
from qtasks.logs import Logger

logger = Logger(name="QueueTasks", subname="Global")
app = QueueTasks(log=logger)

app.log.debug("Test") # asctime [QueueTasks: DEBUG] (QueueTasks) Test
Source code in src/qtasks/logs.py 
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
class Logger:
    """`Logger` - Logging class, used by all components.

    ## Example

    ```python
    from qtasks import QueueTasks
    from qtasks.logs import Logger

    logger = Logger(name="QueueTasks", subname="Global")
    app = QueueTasks(log=logger)

    app.log.debug("Test") # asctime [QueueTasks: DEBUG] (QueueTasks) Test
    ```
    """

    def __init__(
        self,
        name: Annotated[
            str,
            Doc("""
                    Name. Used in the `%(name)s` pattern.
                    """),
        ],
        subname: Annotated[
            str | None,
            Doc("""
                    Component name.

                    Default: None.
                    """),
        ] = None,
        default_level: Annotated[
            int,
            Doc("""
                    Level by default.

                    Default: `logging.INFO`.
                    """),
        ] = logging.INFO,
        format: Annotated[
            str | None,
            Doc("""
                    Logging format.

                    Default: `%(asctime)s [%(name)s: %(levelname)s] (%(subname)s) %(message)s`.
                    """),
        ] = None,
    ):
        """
        Logger instance.

        Args:
            name (str): Name. Used in the `%(name)s` pattern.
            subname (str, optional): Component name. Default: `None`.
            default_level (int, optional): Default level. Default: `logging.DEBUG`.
            format (str, optional): Logging format.
        """
        self.name = name
        self.name = name
        self.subname = subname or "-"
        self.format = format
        self.default_level = default_level
        self.logger = logging.getLogger(name)

        formatter = logging.Formatter(
            self.format
            or "%(asctime)s [%(name)s: %(levelname)s] (%(subname)s) %(message)s"
        )

        if not self.logger.handlers:
            handler = logging.StreamHandler()
            handler.setFormatter(formatter)
            self.logger.addHandler(handler)

        self.logger.setLevel(default_level)

    def critical(self, *args, **kwargs):
        """Critical."""
        self._log(logging.CRITICAL, *args, **kwargs)

    def error(self, *args, **kwargs):
        """Error."""
        self._log(logging.ERROR, *args, **kwargs)

    def warning(self, *args, **kwargs):
        """Warning."""
        self._log(logging.WARNING, *args, **kwargs)

    def info(self, *args, **kwargs):
        """Info."""
        self._log(logging.INFO, *args, **kwargs)

    def debug(self, *args, **kwargs):
        """Debug."""
        self._log(logging.DEBUG, *args, **kwargs)

    def with_subname(
        self,
        new_subname: str,
        default_level: int | None = None,
        format: str | None = None,
    ) -> Logger:
        """
        Update `subname`.

        Args:
            new_subname (str): New `subname`.
            default_level (int, optional): New logging level. Default: `None`.
            format (str, optional): New logging format. Default: `None`.

        Returns:
            Logger: New `Logger`.
        """
        return Logger(
            self.name,
            new_subname,
            default_level=default_level or self.default_level,
            format=format or self.format,
        )

    def update_logger(self, **kwargs) -> Logger:
        """
        Update `Logger`.

        Args:
            kwargs (dict): New task data.

        Returns:
            Logger: New `Logger`.
        """
        name = kwargs.get("name") or self.name
        subname = kwargs.get("subname") or self.subname
        default_level = kwargs.get("default_level") or self.default_level
        format = kwargs.get("format") or self.format
        return Logger(
            name=name, subname=subname, default_level=default_level, format=format
        )

    def _log(self, level, msg, *args, **kwargs):
        extra = kwargs.pop("extra", {})
        if "subname" not in extra:
            extra["subname"] = self.subname
        self.logger.log(level, msg, *args, extra=extra, **kwargs)

__init__(name, subname=None, default_level=logging.INFO, format=None)

Logger instance.

Parameters:

Name Type Description Default
name str

Name. Used in the %(name)s pattern.

 required
subname str

Component name. Default: None.

 None
default_level int

Default level. Default: logging.DEBUG.

 INFO
format str

Logging format.

 None
Source code in src/qtasks/logs.py 
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
def __init__(
    self,
    name: Annotated[
        str,
        Doc("""
                Name. Used in the `%(name)s` pattern.
                """),
    ],
    subname: Annotated[
        str | None,
        Doc("""
                Component name.

                Default: None.
                """),
    ] = None,
    default_level: Annotated[
        int,
        Doc("""
                Level by default.

                Default: `logging.INFO`.
                """),
    ] = logging.INFO,
    format: Annotated[
        str | None,
        Doc("""
                Logging format.

                Default: `%(asctime)s [%(name)s: %(levelname)s] (%(subname)s) %(message)s`.
                """),
    ] = None,
):
    """
    Logger instance.

    Args:
        name (str): Name. Used in the `%(name)s` pattern.
        subname (str, optional): Component name. Default: `None`.
        default_level (int, optional): Default level. Default: `logging.DEBUG`.
        format (str, optional): Logging format.
    """
    self.name = name
    self.name = name
    self.subname = subname or "-"
    self.format = format
    self.default_level = default_level
    self.logger = logging.getLogger(name)

    formatter = logging.Formatter(
        self.format
        or "%(asctime)s [%(name)s: %(levelname)s] (%(subname)s) %(message)s"
    )

    if not self.logger.handlers:
        handler = logging.StreamHandler()
        handler.setFormatter(formatter)
        self.logger.addHandler(handler)

    self.logger.setLevel(default_level)

critical(*args, **kwargs)

Critical.

Source code in src/qtasks/logs.py 
87
88
89
def critical(self, *args, **kwargs):
    """Critical."""
    self._log(logging.CRITICAL, *args, **kwargs)

debug(*args, **kwargs)

Debug.

Source code in src/qtasks/logs.py 
103
104
105
def debug(self, *args, **kwargs):
    """Debug."""
    self._log(logging.DEBUG, *args, **kwargs)

error(*args, **kwargs)

Error.

Source code in src/qtasks/logs.py 
91
92
93
def error(self, *args, **kwargs):
    """Error."""
    self._log(logging.ERROR, *args, **kwargs)

info(*args, **kwargs)

Info.

Source code in src/qtasks/logs.py 
 99
100
101
def info(self, *args, **kwargs):
    """Info."""
    self._log(logging.INFO, *args, **kwargs)

update_logger(**kwargs)

Update Logger.

Parameters:

Name Type Description Default
kwargs dict

New task data.

 {}

Returns:

Name Type Description
Logger Logger

New Logger.
Source code in src/qtasks/logs.py 
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
def update_logger(self, **kwargs) -> Logger:
    """
    Update `Logger`.

    Args:
        kwargs (dict): New task data.

    Returns:
        Logger: New `Logger`.
    """
    name = kwargs.get("name") or self.name
    subname = kwargs.get("subname") or self.subname
    default_level = kwargs.get("default_level") or self.default_level
    format = kwargs.get("format") or self.format
    return Logger(
        name=name, subname=subname, default_level=default_level, format=format
    )

warning(*args, **kwargs)

Warning.

Source code in src/qtasks/logs.py 
95
96
97
def warning(self, *args, **kwargs):
    """Warning."""
    self._log(logging.WARNING, *args, **kwargs)

with_subname(new_subname, default_level=None, format=None)

Update subname.

Parameters:

Name Type Description Default
new_subname str

New subname.

 required
default_level int

New logging level. Default: None.

 None
format str

New logging format. Default: None.

 None

Returns:

Name Type Description
Logger Logger

New Logger.
Source code in src/qtasks/logs.py 
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
def with_subname(
    self,
    new_subname: str,
    default_level: int | None = None,
    format: str | None = None,
) -> Logger:
    """
    Update `subname`.

    Args:
        new_subname (str): New `subname`.
        default_level (int, optional): New logging level. Default: `None`.
        format (str, optional): New logging format. Default: `None`.

    Returns:
        Logger: New `Logger`.
    """
    return Logger(
        self.name,
        new_subname,
        default_level=default_level or self.default_level,
        format=format or self.format,
    )