From c21c3b0befeb46a51b6bf3758ffa30813bea0ff0 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 9 Mar 2024 14:19:22 +0100 Subject: Adding upstream version 1.44.3. Signed-off-by: Daniel Baumann --- .../bases/FrameworkServices/SimpleService.py | 6 +- .../bases/FrameworkServices/UrlService.py | 19 --- .../python_modules/bases/loggers.py | 182 ++++++++++----------- 3 files changed, 90 insertions(+), 117 deletions(-) (limited to 'collectors/python.d.plugin/python_modules/bases') diff --git a/collectors/python.d.plugin/python_modules/bases/FrameworkServices/SimpleService.py b/collectors/python.d.plugin/python_modules/bases/FrameworkServices/SimpleService.py index a7acc23b6..3f122e1d9 100644 --- a/collectors/python.d.plugin/python_modules/bases/FrameworkServices/SimpleService.py +++ b/collectors/python.d.plugin/python_modules/bases/FrameworkServices/SimpleService.py @@ -8,7 +8,7 @@ import os from bases.charts import Charts, ChartError, create_runtime_chart from bases.collection import safe_print -from bases.loggers import PythonDLimitedLogger +from bases.loggers import PythonDLogger from third_party.monotonic import monotonic from time import sleep, time @@ -62,7 +62,7 @@ def clean_module_name(name): return name -class SimpleService(PythonDLimitedLogger, object): +class SimpleService(PythonDLogger, object): """ Prototype of Service class. Implemented basic functionality to run jobs by `python.d.plugin` @@ -73,7 +73,7 @@ class SimpleService(PythonDLimitedLogger, object): :param configuration: :param name: """ - PythonDLimitedLogger.__init__(self) + PythonDLogger.__init__(self) self.configuration = configuration self.order = list() self.definitions = dict() diff --git a/collectors/python.d.plugin/python_modules/bases/FrameworkServices/UrlService.py b/collectors/python.d.plugin/python_modules/bases/FrameworkServices/UrlService.py index 1faf036a4..76129d376 100644 --- a/collectors/python.d.plugin/python_modules/bases/FrameworkServices/UrlService.py +++ b/collectors/python.d.plugin/python_modules/bases/FrameworkServices/UrlService.py @@ -6,8 +6,6 @@ import urllib3 -from distutils.version import StrictVersion as version - from bases.FrameworkServices.SimpleService import SimpleService try: @@ -15,28 +13,11 @@ try: except AttributeError: pass -# https://github.com/urllib3/urllib3/blob/master/CHANGES.rst#19-2014-07-04 -# New retry logic and urllib3.util.retry.Retry configuration object. (Issue https://github.com/urllib3/urllib3/pull/326) -URLLIB3_MIN_REQUIRED_VERSION = '1.9' URLLIB3_VERSION = urllib3.__version__ URLLIB3 = 'urllib3' - -def version_check(): - if version(URLLIB3_VERSION) >= version(URLLIB3_MIN_REQUIRED_VERSION): - return - - err = '{0} version: {1}, minimum required version: {2}, please upgrade'.format( - URLLIB3, - URLLIB3_VERSION, - URLLIB3_MIN_REQUIRED_VERSION, - ) - raise Exception(err) - - class UrlService(SimpleService): def __init__(self, configuration=None, name=None): - version_check() SimpleService.__init__(self, configuration=configuration, name=name) self.debug("{0} version: {1}".format(URLLIB3, URLLIB3_VERSION)) self.url = self.configuration.get('url') diff --git a/collectors/python.d.plugin/python_modules/bases/loggers.py b/collectors/python.d.plugin/python_modules/bases/loggers.py index 47f196a6d..7ae8ab0c1 100644 --- a/collectors/python.d.plugin/python_modules/bases/loggers.py +++ b/collectors/python.d.plugin/python_modules/bases/loggers.py @@ -4,6 +4,8 @@ # SPDX-License-Identifier: GPL-3.0-or-later import logging +import os +import stat import traceback from sys import exc_info @@ -15,39 +17,46 @@ except ImportError: from bases.collection import on_try_except_finally, unicode_str +LOGGING_LEVELS = { + 'CRITICAL': 50, + 'ERROR': 40, + 'WARNING': 30, + 'INFO': 20, + 'DEBUG': 10, + 'NOTSET': 0, +} -LOGGING_LEVELS = {'CRITICAL': 50, - 'ERROR': 40, - 'WARNING': 30, - 'INFO': 20, - 'DEBUG': 10, - 'NOTSET': 0} -DEFAULT_LOG_LINE_FORMAT = '%(asctime)s: %(name)s %(levelname)s : %(message)s' -DEFAULT_LOG_TIME_FORMAT = '%Y-%m-%d %H:%M:%S' +def is_stderr_connected_to_journal(): + journal_stream = os.environ.get("JOURNAL_STREAM") + if not journal_stream: + return False -PYTHON_D_LOG_LINE_FORMAT = '%(asctime)s: %(name)s %(levelname)s: %(module_name)s[%(job_name)s] : %(message)s' -PYTHON_D_LOG_NAME = 'python.d' + colon_index = journal_stream.find(":") + if colon_index <= 0: + return False + device, inode = journal_stream[:colon_index], journal_stream[colon_index + 1:] -def limiter(log_max_count=30, allowed_in_seconds=60): - def on_decorator(func): + try: + device_number, inode_number = os.fstat(2)[stat.ST_DEV], os.fstat(2)[stat.ST_INO] + except OSError: + return False - def on_call(*args): - current_time = args[0]._runtime_counters.start_mono - lc = args[0]._logger_counters + return str(device_number) == device and str(inode_number) == inode - if lc.logged and lc.logged % log_max_count == 0: - if current_time - lc.time_to_compare <= allowed_in_seconds: - lc.dropped += 1 - return - lc.time_to_compare = current_time - lc.logged += 1 - func(*args) +is_journal = is_stderr_connected_to_journal() + +DEFAULT_LOG_LINE_FORMAT = '%(asctime)s: %(name)s %(levelname)s : %(message)s' +PYTHON_D_LOG_LINE_FORMAT = '%(asctime)s: %(name)s %(levelname)s: %(module_name)s[%(job_name)s] : %(message)s' + +if is_journal: + DEFAULT_LOG_LINE_FORMAT = '%(name)s %(levelname)s : %(message)s' + PYTHON_D_LOG_LINE_FORMAT = '%(name)s %(levelname)s: %(module_name)s[%(job_name)s] : %(message)s ' - return on_call - return on_decorator +DEFAULT_LOG_TIME_FORMAT = '%Y-%m-%d %H:%M:%S' +PYTHON_D_LOG_NAME = 'python.d' def add_traceback(func): @@ -66,27 +75,16 @@ def add_traceback(func): return on_call -class LoggerCounters: - def __init__(self): - self.logged = 0 - self.dropped = 0 - self.time_to_compare = time() - - def __repr__(self): - return 'LoggerCounter(logged: {logged}, dropped: {dropped})'.format(logged=self.logged, - dropped=self.dropped) - - class BaseLogger(object): - def __init__(self, logger_name, log_fmt=DEFAULT_LOG_LINE_FORMAT, date_fmt=DEFAULT_LOG_TIME_FORMAT, - handler=logging.StreamHandler): - """ - :param logger_name: - :param log_fmt: - :param date_fmt: - :param handler: - """ + def __init__( + self, + logger_name, + log_fmt=DEFAULT_LOG_LINE_FORMAT, + date_fmt=DEFAULT_LOG_TIME_FORMAT, + handler=logging.StreamHandler, + ): self.logger = logging.getLogger(logger_name) + self._muted = False if not self.has_handlers(): self.severity = 'INFO' self.logger.addHandler(handler()) @@ -96,11 +94,6 @@ class BaseLogger(object): return ''.format(name=self.logger.name) def set_formatter(self, fmt, date_fmt=DEFAULT_LOG_TIME_FORMAT): - """ - :param fmt: - :param date_fmt: - :return: - """ if self.has_handlers(): self.logger.handlers[0].setFormatter(logging.Formatter(fmt=fmt, datefmt=date_fmt)) @@ -113,43 +106,48 @@ class BaseLogger(object): @severity.setter def severity(self, level): - """ - :param level: or - :return: - """ if level in LOGGING_LEVELS: self.logger.setLevel(LOGGING_LEVELS[level]) + def _log(self, level, *msg, **kwargs): + if not self._muted: + self.logger.log(level, ' '.join(map(unicode_str, msg)), **kwargs) + def debug(self, *msg, **kwargs): - self.logger.debug(' '.join(map(unicode_str, msg)), **kwargs) + self._log(logging.DEBUG, *msg, **kwargs) def info(self, *msg, **kwargs): - self.logger.info(' '.join(map(unicode_str, msg)), **kwargs) + self._log(logging.INFO, *msg, **kwargs) def warning(self, *msg, **kwargs): - self.logger.warning(' '.join(map(unicode_str, msg)), **kwargs) + self._log(logging.WARN, *msg, **kwargs) def error(self, *msg, **kwargs): - self.logger.error(' '.join(map(unicode_str, msg)), **kwargs) + self._log(logging.ERROR, *msg, **kwargs) - def alert(self, *msg, **kwargs): - self.logger.critical(' '.join(map(unicode_str, msg)), **kwargs) + def alert(self, *msg, **kwargs): + self._log(logging.CRITICAL, *msg, **kwargs) @on_try_except_finally(on_finally=(exit, 1)) def fatal(self, *msg, **kwargs): - self.logger.critical(' '.join(map(unicode_str, msg)), **kwargs) + self._log(logging.CRITICAL, *msg, **kwargs) + + def mute(self): + self._muted = True + + def unmute(self): + self._muted = False class PythonDLogger(object): - def __init__(self, logger_name=PYTHON_D_LOG_NAME, log_fmt=PYTHON_D_LOG_LINE_FORMAT): - """ - :param logger_name: - :param log_fmt: - """ + def __init__( + self, + logger_name=PYTHON_D_LOG_NAME, + log_fmt=PYTHON_D_LOG_LINE_FORMAT, + ): self.logger = BaseLogger(logger_name, log_fmt=log_fmt) self.module_name = 'plugin' self.job_name = 'main' - self._logger_counters = LoggerCounters() _LOG_TRACEBACK = False @@ -162,45 +160,39 @@ class PythonDLogger(object): PythonDLogger._LOG_TRACEBACK = value def debug(self, *msg): - self.logger.debug(*msg, extra={'module_name': self.module_name, - 'job_name': self.job_name or self.module_name}) + self.logger.debug(*msg, extra={ + 'module_name': self.module_name, + 'job_name': self.job_name or self.module_name, + }) def info(self, *msg): - self.logger.info(*msg, extra={'module_name': self.module_name, - 'job_name': self.job_name or self.module_name}) + self.logger.info(*msg, extra={ + 'module_name': self.module_name, + 'job_name': self.job_name or self.module_name, + }) def warning(self, *msg): - self.logger.warning(*msg, extra={'module_name': self.module_name, - 'job_name': self.job_name or self.module_name}) + self.logger.warning(*msg, extra={ + 'module_name': self.module_name, + 'job_name': self.job_name or self.module_name, + }) @add_traceback def error(self, *msg): - self.logger.error(*msg, extra={'module_name': self.module_name, - 'job_name': self.job_name or self.module_name}) + self.logger.error(*msg, extra={ + 'module_name': self.module_name, + 'job_name': self.job_name or self.module_name, + }) @add_traceback def alert(self, *msg): - self.logger.alert(*msg, extra={'module_name': self.module_name, - 'job_name': self.job_name or self.module_name}) + self.logger.alert(*msg, extra={ + 'module_name': self.module_name, + 'job_name': self.job_name or self.module_name, + }) def fatal(self, *msg): - self.logger.fatal(*msg, extra={'module_name': self.module_name, - 'job_name': self.job_name or self.module_name}) - - -class PythonDLimitedLogger(PythonDLogger): - @limiter() - def info(self, *msg): - PythonDLogger.info(self, *msg) - - @limiter() - def warning(self, *msg): - PythonDLogger.warning(self, *msg) - - @limiter() - def error(self, *msg): - PythonDLogger.error(self, *msg) - - @limiter() - def alert(self, *msg): - PythonDLogger.alert(self, *msg) + self.logger.fatal(*msg, extra={ + 'module_name': self.module_name, + 'job_name': self.job_name or self.module_name, + }) -- cgit v1.2.3