FM / logger

/usr/lib/python3/dist-packages/twisted/logger/

/usr/lib/python3/dist-packages/twisted/logger

Name	Size	Mode	Actions
test/	-	0755	rm
__pycache__/	-	0755	rm
_buffer.py	1529	0644	edit dl rm
_capture.py	624	0644	edit dl rm
_file.py	2337	0644	edit dl rm
_filter.py	6895	0644	edit dl rm
_flatten.py	4996	0644	edit dl rm
_format.py	11874	0644	edit dl rm
_global.py	8638	0644	edit dl rm
_interfaces.py	2348	0644	edit dl rm
_io.py	4568	0644	edit dl rm
_json.py	8433	0644	edit dl rm
_legacy.py	5241	0644	edit dl rm
_levels.py	2985	0644	edit dl rm
_logger.py	9982	0644	edit dl rm
_observer.py	3241	0644	edit dl rm
_stdlib.py	4546	0644	edit dl rm
_util.py	1400	0644	edit dl rm
__init__.py	3369	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/twisted/logger/_filter.py (6895B)

# -*- test-case-name: twisted.logger.test.test_filter -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Filtering log observer.
"""

from functools import partial
from typing import Dict, Iterable

from zope.interface import Interface, implementer

from constantly import NamedConstant, Names  # type: ignore[import]

from ._interfaces import ILogObserver, LogEvent
from ._levels import InvalidLogLevelError, LogLevel
from ._observer import bitbucketLogObserver

class PredicateResult(Names):
    """
    Predicate results.

@see: L{LogLevelFilterPredicate}

@cvar yes: Log the specified event.  When this value is used,
        L{FilteringLogObserver} will always log the message, without
        evaluating other predicates.

@cvar no: Do not log the specified event.  When this value is used,
        L{FilteringLogObserver} will I{not} log the message, without
        evaluating other predicates.

@cvar maybe: Do not have an opinion on the event.  When this value is used,
        L{FilteringLogObserver} will consider subsequent predicate results;
        if returned by the last predicate being considered, then the event will
        be logged.
    """

yes = NamedConstant()
    no = NamedConstant()
    maybe = NamedConstant()

class ILogFilterPredicate(Interface):
    """
    A predicate that determined whether an event should be logged.
    """

def __call__(event: LogEvent) -> NamedConstant:
        """
        Determine whether an event should be logged.

@returns: a L{PredicateResult}.
        """

def shouldLogEvent(predicates: Iterable[ILogFilterPredicate], event: LogEvent) -> bool:
    """
    Determine whether an event should be logged, based on the result of
    C{predicates}.

By default, the result is C{True}; so if there are no predicates,
    everything will be logged.

If any predicate returns C{yes}, then we will immediately return C{True}.

If any predicate returns C{no}, then we will immediately return C{False}.

As predicates return C{maybe}, we keep calling the next predicate until we
    run out, at which point we return C{True}.

@param predicates: The predicates to use.
    @param event: An event

@return: True if the message should be forwarded on, C{False} if not.
    """
    for predicate in predicates:
        result = predicate(event)
        if result == PredicateResult.yes:
            return True
        if result == PredicateResult.no:
            return False
        if result == PredicateResult.maybe:
            continue
        raise TypeError(f"Invalid predicate result: {result!r}")
    return True

@implementer(ILogObserver)
class FilteringLogObserver:
    """
    L{ILogObserver} that wraps another L{ILogObserver}, but filters out events
    based on applying a series of L{ILogFilterPredicate}s.
    """

def __init__(
        self,
        observer: ILogObserver,
        predicates: Iterable[ILogFilterPredicate],
        negativeObserver: ILogObserver = bitbucketLogObserver,
    ) -> None:
        """
        @param observer: An observer to which this observer will forward
            events when C{predictates} yield a positive result.
        @param predicates: Predicates to apply to events before forwarding to
            the wrapped observer.
        @param negativeObserver: An observer to which this observer will
            forward events when C{predictates} yield a negative result.
        """
        self._observer = observer
        self._shouldLogEvent = partial(shouldLogEvent, list(predicates))
        self._negativeObserver = negativeObserver

def __call__(self, event: LogEvent) -> None:
        """
        Forward to next observer if predicate allows it.
        """
        if self._shouldLogEvent(event):
            if "log_trace" in event:
                event["log_trace"].append((self, self._observer))
            self._observer(event)
        else:
            self._negativeObserver(event)

@implementer(ILogFilterPredicate)
class LogLevelFilterPredicate:
    """
    L{ILogFilterPredicate} that filters out events with a log level lower than
    the log level for the event's namespace.

Events that not not have a log level or namespace are also dropped.
    """

def __init__(self, defaultLogLevel: NamedConstant = LogLevel.info) -> None:
        """
        @param defaultLogLevel: The default minimum log level.
        """
        self._logLevelsByNamespace: Dict[str, NamedConstant] = {}
        self.defaultLogLevel = defaultLogLevel
        self.clearLogLevels()

def logLevelForNamespace(self, namespace: str) -> NamedConstant:
        """
        Determine an appropriate log level for the given namespace.

This respects dots in namespaces; for example, if you have previously
        invoked C{setLogLevelForNamespace("mypackage", LogLevel.debug)}, then
        C{logLevelForNamespace("mypackage.subpackage")} will return
        C{LogLevel.debug}.

@param namespace: A logging namespace.  Use C{""} for the default
            namespace.

@return: The log level for the specified namespace.
        """
        if not namespace:
            return self._logLevelsByNamespace[""]

if namespace in self._logLevelsByNamespace:
            return self._logLevelsByNamespace[namespace]

segments = namespace.split(".")
        index = len(segments) - 1

while index > 0:
            namespace = ".".join(segments[:index])
            if namespace in self._logLevelsByNamespace:
                return self._logLevelsByNamespace[namespace]
            index -= 1

return self._logLevelsByNamespace[""]

def setLogLevelForNamespace(self, namespace: str, level: NamedConstant) -> None:
        """
        Sets the log level for a logging namespace.

@param namespace: A logging namespace.
        @param level: The log level for the given namespace.
        """
        if level not in LogLevel.iterconstants():
            raise InvalidLogLevelError(level)

if namespace:
            self._logLevelsByNamespace[namespace] = level
        else:
            self._logLevelsByNamespace[""] = level

def clearLogLevels(self) -> None:
        """
        Clears all log levels to the default.
        """
        self._logLevelsByNamespace.clear()
        self._logLevelsByNamespace[""] = self.defaultLogLevel

def __call__(self, event: LogEvent) -> NamedConstant:
        eventLevel = event.get("log_level", None)
        if eventLevel is None:
            return PredicateResult.no

namespace = event.get("log_namespace", "")
        if not namespace:
            return PredicateResult.no

namespaceLevel = self.logLevelForNamespace(namespace)
        if eventLevel < namespaceLevel:
            return PredicateResult.no

return PredicateResult.maybe

cmd: