c2cwsgiutils 6.1.0.dev105__py3-none-any.whl → 6.1.1__py3-none-any.whl

c2cwsgiutils/health_check.py

@@ -16,7 +16,7 @@ import traceback
 from collections.abc import Mapping
 from enum import Enum
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, Union, cast
+from typing import Any, Callable, Literal, Optional, Union, cast
 
 import prometheus_client
 import pyramid.config
@@ -30,13 +30,10 @@ from pyramid.httpexceptions import HTTPNotFound
 import c2cwsgiutils.db
 from c2cwsgiutils import auth, broadcast, config_utils, prometheus, redis_utils, version
 
-if TYPE_CHECKING:
-    scoped_session = sqlalchemy.orm.scoped_session[sqlalchemy.orm.Session]
-else:
-    scoped_session = sqlalchemy.orm.scoped_session
+_scoped_session = sqlalchemy.orm.scoped_session[sqlalchemy.orm.Session]
 
-LOG = logging.getLogger(__name__)
-ALEMBIC_HEAD_RE = re.compile(r"^([a-f0-9]+) \(head\)\n$")
+_LOG = logging.getLogger(__name__)
+_ALEMBIC_HEAD_RE = re.compile(r"^([a-f0-9]+) \(head\)\n$")
 
 _PROMETHEUS_DB_SUMMARY = prometheus_client.Summary(
     prometheus.build_metric_name("health_check_db"),
@@ -78,14 +75,16 @@ class JsonCheckException(Exception):
         return self.message
 
     def json_data(self) -> Any:
+        """Return the JSON data to be returned in the response."""
         return self.json
 
 
 class _Binding:
     def name(self) -> str:
+        """Return the name of the binding."""
         raise NotImplementedError()
 
-    def __enter__(self) -> scoped_session:
+    def __enter__(self) -> _scoped_session:
         raise NotImplementedError()
 
     def __exit__(
@@ -105,12 +104,12 @@ class _NewBinding(_Binding):
     def name(self) -> str:
         return self.session.engine_name(self.readwrite)
 
-    def __enter__(self) -> scoped_session:
+    def __enter__(self) -> _scoped_session:
         return self.session(None, self.readwrite)
 
 
 class _OldBinding(_Binding):
-    def __init__(self, session: scoped_session, engine: sqlalchemy.engine.Engine):
+    def __init__(self, session: _scoped_session, engine: sqlalchemy.engine.Engine):
         self.session = session
         self.engine = engine
         self.prev_bind = None
@@ -118,7 +117,7 @@ class _OldBinding(_Binding):
     def name(self) -> str:
         return cast(str, self.engine.c2c_name)  # type: ignore
 
-    def __enter__(self) -> scoped_session:
+    def __enter__(self) -> _scoped_session:
         self.prev_bind = self.session.bind  # type: ignore
         self.session.bind = self.engine
         return self.session
@@ -134,7 +133,7 @@ class _OldBinding(_Binding):
 
 
 def _get_binding_class(
-    session: Union[scoped_session, c2cwsgiutils.db.SessionFactory],
+    session: Union[_scoped_session, c2cwsgiutils.db.SessionFactory],
     ro_engin: sqlalchemy.engine.Engine,
     rw_engin: sqlalchemy.engine.Engine,
     readwrite: bool,
@@ -146,7 +145,7 @@ def _get_binding_class(
 
 
 def _get_bindings(
-    session: Union[scoped_session, c2cwsgiutils.db.SessionFactory],
+    session: Union[_scoped_session, c2cwsgiutils.db.SessionFactory],
     engine_type: EngineType,
 ) -> list[_Binding]:
     if isinstance(session, c2cwsgiutils.db.SessionFactory):
@@ -184,7 +183,7 @@ def _get_alembic_version(alembic_ini_path: str, name: str) -> str:
     out = subprocess.check_output(  # nosec
         ["alembic", "--config", alembic_ini_path, "--name", name, "heads"], cwd=dirname, env=env
     ).decode("utf-8")
-    out_match = ALEMBIC_HEAD_RE.match(out)
+    out_match = _ALEMBIC_HEAD_RE.match(out)
     if not out_match:
         raise Exception(  # pylint: disable=broad-exception-raised
             "Cannot get the alembic HEAD version from: " + out
@@ -219,8 +218,8 @@ class HealthCheck:
 
     def add_db_session_check(
         self,
-        session: Union[scoped_session, c2cwsgiutils.db.SessionFactory],
-        query_cb: Optional[Callable[[scoped_session], Any]] = None,
+        session: Union[_scoped_session, c2cwsgiutils.db.SessionFactory],
+        query_cb: Optional[Callable[[_scoped_session], Any]] = None,
         at_least_one_model: Optional[object] = None,
         level: int = 1,
         engine_type: EngineType = EngineType.READ_AND_WRITE,
@@ -229,7 +228,6 @@ class HealthCheck:
         Check a DB session is working. You can specify either query_cb or at_least_one_model.
 
         Arguments:
-
             session: a DB session created by c2cwsgiutils.db.init()
             query_cb: a callable that take a session as parameter and check it works
             at_least_one_model: a model that must have at least one entry in the DB
@@ -247,7 +245,7 @@ class HealthCheck:
 
     def add_alembic_check(
         self,
-        session: scoped_session,
+        session: _scoped_session,
         alembic_ini_path: str,
         level: int = 2,
         name: str = "alembic",
@@ -258,7 +256,6 @@ class HealthCheck:
         Check the DB version against the HEAD version of Alembic.
 
         Arguments:
-
             session: A DB session created by c2cwsgiutils.db.init() giving access to the DB \
                         managed by Alembic
             alembic_ini_path: Path to the Alembic INI file
@@ -283,7 +280,7 @@ class HealthCheck:
         assert version_table
 
         class _Check:
-            def __init__(self, session: scoped_session) -> None:
+            def __init__(self, session: _scoped_session) -> None:
                 self.session = session
 
             def __call__(self, request: pyramid.request.Request) -> str:
@@ -334,7 +331,6 @@ class HealthCheck:
         Check that a GET on an URL returns 2xx.
 
         Arguments:
-
             url: the URL to query or a function taking the request and returning it
             params: the parameters or a function taking the request and returning them
             headers: the headers or a function taking the request and returning them
@@ -367,7 +363,6 @@ class HealthCheck:
         One such check is automatically added if the broadcaster is configured with redis.
 
         Arguments:
-
             name: the name of the check (defaults to url)
             level: the level of the health check
         """
@@ -415,13 +410,13 @@ class HealthCheck:
         """
         Check that the version matches across all instances.
 
-        Keyword Arguments:
-
+        Arguments:
             name: the name of the check (defaults to "version")
             level: the level of the health check
         """
 
         def check(request: pyramid.request.Request) -> dict[str, Any]:
+            del request  # unused
             ref = version.get_version()
             all_versions = _get_all_versions()
             assert all_versions
@@ -443,7 +438,6 @@ class HealthCheck:
         in the response. In case of failure it must raise an exception.
 
         Arguments:
-
             name: the name of the check
             check_cb: the callback to call (takes the request as parameter)
             level: the level of the health check
@@ -489,7 +483,7 @@ class HealthCheck:
             _set_success(check_name=name)
         except Exception as e:  # pylint: disable=broad-except
             _PROMETHEUS_HEALTH_CHECKS_FAILURE.labels(name=name).set(1)
-            LOG.warning("Health check %s failed", name, exc_info=True)
+            _LOG.warning("Health check %s failed", name, exc_info=True)
             failure = {"message": str(e), "timing": time.perf_counter() - start, "level": level}
             if isinstance(e, JsonCheckException) and e.json_data() is not None:
                 failure["result"] = e.json_data()
@@ -500,9 +494,10 @@ class HealthCheck:
     @staticmethod
     def _create_db_engine_check(
         binding: _Binding,
-        query_cb: Callable[[scoped_session], None],
+        query_cb: Callable[[_scoped_session], None],
     ) -> tuple[str, Callable[[pyramid.request.Request], None]]:
         def check(request: pyramid.request.Request) -> None:
+            del request  # unused
             with binding as session:
                 with _PROMETHEUS_DB_SUMMARY.labels(
                     connection=binding.name(), check="database", configuration="<default>"
@@ -512,8 +507,8 @@ class HealthCheck:
         return "db_engine_" + binding.name(), check
 
     @staticmethod
-    def _at_least_one(model: Any) -> Callable[[scoped_session], Any]:
-        def query(session: scoped_session) -> None:
+    def _at_least_one(model: Any) -> Callable[[_scoped_session], Any]:
+        def query(session: _scoped_session) -> None:
             result = session.query(model).first()
             if result is None:
                 raise HTTPNotFound(model.__name__ + " record not found")
@@ -528,7 +523,6 @@ def _maybe_function(what: Any, request: pyramid.request.Request) -> Any:
 @broadcast.decorator(expect_answers=False)
 def _set_success(check_name: str) -> None:
     """Set check in success in all process."""
-
     _PROMETHEUS_HEALTH_CHECKS_FAILURE.labels(name=check_name).set(0)
 
 

c2cwsgiutils/index.py

@@ -42,12 +42,12 @@ from c2cwsgiutils.auth import (
 )
 from c2cwsgiutils.config_utils import env_or_settings
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 additional_title: Optional[str] = None
 additional_noauth: list[str] = []
 additional_auth: list[str] = []
-ELEM_ID = 0
+_ELEM_ID = 0
 
 
 def _url(
@@ -113,9 +113,9 @@ def input_(
     name: str, label: Optional[str] = None, type_: Optional[str] = None, value: Union[str, int] = ""
 ) -> str:
     """Get an HTML input."""
-    global ELEM_ID
-    id_ = ELEM_ID
-    ELEM_ID += 1
+    global _ELEM_ID  # pylint: disable=global-statement
+    id_ = _ELEM_ID
+    _ELEM_ID += 1
 
     if label is None and type_ != "hidden":
         label = name.replace("_", " ").capitalize()
@@ -138,7 +138,6 @@ def input_(
 
 def button(label: str) -> str:
     """Get en HTML button."""
-
     return f'<button class="btn btn-primary" type="submit">{label}</button>'
 
 
@@ -153,8 +152,8 @@ def _index(request: pyramid.request.Request) -> dict[str, str]:
     body = ""
     body += _health_check(request)
     body += _stats(request)
-    body += _versions(request)
     if has_access:
+        body += _versions(request)
         body += _debug(request)
         body += _db_maintenance(request)
         body += _logging(request)
@@ -346,7 +345,6 @@ def _health_check(request: pyramid.request.Request) -> str:
 
 def _github_login(request: pyramid.request.Request) -> dict[str, Any]:
     """Get the view that start the authentication on GitHub."""
-
     settings = request.registry.settings
     params = dict(request.params)
     callback_url = _url(
@@ -500,7 +498,7 @@ def includeme(config: pyramid.config.Configurator) -> None:
         settings = config.get_settings()
         auth_type_ = auth_type(settings)
         if auth_type_ == AuthenticationType.SECRET:
-            LOG.warning(
+            _LOG.warning(
                 "It is recommended to use OAuth2 with GitHub login instead of the `C2C_SECRET` because it "
                 "protects from brute force attacks and the access grant is personal and can be revoked."
             )

c2cwsgiutils/loader.py

@@ -5,7 +5,7 @@ from plaster_pastedeploy import Loader as BaseLoader
 
 from c2cwsgiutils import get_config_defaults
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 
 class Loader(BaseLoader):  # type: ignore

c2cwsgiutils/logging_view.py

@@ -7,10 +7,10 @@ import pyramid.request
 
 from c2cwsgiutils import auth, broadcast, config_utils, redis_utils
 
-LOG = logging.getLogger(__name__)
-CONFIG_KEY = "c2c.log_view_enabled"
-ENV_KEY = "C2C_LOG_VIEW_ENABLED"
-REDIS_PREFIX = "c2c_logging_level_"
+_LOG = logging.getLogger(__name__)
+_CONFIG_KEY = "c2c.log_view_enabled"
+_ENV_KEY = "C2C_LOG_VIEW_ENABLED"
+_REDIS_PREFIX = "c2c_logging_level_"
 
 
 def install_subscriber(config: pyramid.config.Configurator) -> None:
@@ -21,7 +21,7 @@ def install_subscriber(config: pyramid.config.Configurator) -> None:
 
 def includeme(config: pyramid.config.Configurator) -> None:
     """Install the view to configure the loggers, if configured to do so."""
-    if auth.is_enabled(config, ENV_KEY, CONFIG_KEY):
+    if auth.is_enabled(config, _ENV_KEY, _CONFIG_KEY):
         config.add_route(
             "c2c_logging_level", config_utils.get_base_path(config) + r"/logging/level", request_method="GET"
         )
@@ -29,7 +29,7 @@ def includeme(config: pyramid.config.Configurator) -> None:
             _logging_change_level, route_name="c2c_logging_level", renderer="fast_json", http_cache=0
         )
         _restore_overrides(config)
-        LOG.info("Enabled the /logging/level API")
+        _LOG.info("Enabled the /logging/level API")
 
 
 def _logging_change_level(request: pyramid.request.Request) -> Mapping[str, Any]:
@@ -39,7 +39,7 @@ def _logging_change_level(request: pyramid.request.Request) -> Mapping[str, Any]
         level = request.params.get("level")
         logger = logging.getLogger(name)
         if level is not None:
-            LOG.critical(
+            _LOG.critical(
                 "Logging of %s changed from %s to %s", name, logging.getLevelName(logger.level), level
             )
             _set_level(name=name, level=level)
@@ -63,20 +63,20 @@ def _set_level(name: str, level: str) -> bool:
 def _restore_overrides(config: pyramid.config.Configurator) -> None:
     try:
         for name, level in _list_overrides(config.get_settings()):
-            LOG.debug("Restoring logging level override for %s: %s", name, level)
+            _LOG.debug("Restoring logging level override for %s: %s", name, level)
             logging.getLogger(name).setLevel(level)
     except ImportError:
         pass  # don't have redis
     except Exception:  # pylint: disable=broad-except
         # survive an error there. Logging levels is not business critical...
-        LOG.warning("Cannot restore logging levels", exc_info=True)
+        _LOG.warning("Cannot restore logging levels", exc_info=True)
 
 
 def _store_override(settings: Mapping[str, Any], name: str, level: str) -> None:
     try:
         master, _, _ = redis_utils.get(settings)
         if master:
-            master.set(REDIS_PREFIX + name, level)
+            master.set(_REDIS_PREFIX + name, level)
     except ImportError:
         pass
 
@@ -84,8 +84,8 @@ def _store_override(settings: Mapping[str, Any], name: str, level: str) -> None:
 def _list_overrides(settings: Mapping[str, Any]) -> Generator[tuple[str, str], None, None]:
     _, slave, _ = redis_utils.get(settings)
     if slave is not None:
-        for key in slave.scan_iter(REDIS_PREFIX + "*"):
+        for key in slave.scan_iter(_REDIS_PREFIX + "*"):
             level = slave.get(key)
-            name = key[len(REDIS_PREFIX) :]
+            name = key[len(_REDIS_PREFIX) :]
             if level is not None:
                 yield name, str(level)

c2cwsgiutils/models_graph.py

@@ -7,7 +7,6 @@ import sqlalchemy as sa
 
 def generate_model_graph(module: Any) -> None:
     """Generate a graphical model of the database classes."""
-
     base_name = None
     if len(sys.argv) == 1:
         base_name = "Base"

c2cwsgiutils/pretty_json.py

@@ -34,7 +34,6 @@ def init(config: pyramid.config.Configurator) -> None:
 
 def includeme(config: pyramid.config.Configurator) -> None:
     """Initialize json and fast_json renderer."""
-
     pretty_print = config_bool(
         env_or_config(config, "C2C_JSON_PRETTY_PRINT", "c2c.json.pretty_print", "false")
     )

c2cwsgiutils/prometheus.py

@@ -24,7 +24,6 @@ MULTI_PROCESS_COLLECTOR_BROADCAST_CHANNELS = [
 
 def start(registry: Optional[prometheus_client.CollectorRegistry] = None) -> None:
     """Start separate HTTP server to provide the Prometheus metrics."""
-
     if os.environ.get("C2C_PROMETHEUS_PORT") is not None:
         broadcast.includeme()
 
@@ -38,20 +37,18 @@ def start(registry: Optional[prometheus_client.CollectorRegistry] = None) -> Non
 
 def includeme(config: pyramid.config.Configurator) -> None:
     """Initialize prometheus_client in pyramid context."""
-
+    del config  # unused
     broadcast.subscribe("c2cwsgiutils_prometheus_collector_gc", _broadcast_collector_gc)
     broadcast.subscribe("c2cwsgiutils_prometheus_collector_process", _broadcast_collector_process)
 
 
 def build_metric_name(postfix: str) -> str:
     """Build the metric name with the prefix from the environment variable."""
-
     return os.environ.get("C2C_PROMETHEUS_PREFIX", "c2cwsgiutils_") + postfix
 
 
 def cleanup() -> None:
     """Cleanup the prometheus_client registry."""
-
     redis_utils.cleanup()
     broadcast.cleanup()
 
@@ -74,7 +71,6 @@ class SerializedMetric(TypedDict):
 
 def _broadcast_collector_gc() -> list[SerializedMetric]:
     """Get the collected GC gauges."""
-
     return serialize_collected_data(prometheus_client.GC_COLLECTOR)
 
 
@@ -85,7 +81,6 @@ def _broadcast_collector_process() -> list[SerializedMetric]:
 
 def serialize_collected_data(collector: prometheus_client.registry.Collector) -> list[SerializedMetric]:
     """Serialize the data from the custom collector."""
-
     gauges: list[SerializedMetric] = []
     for process_gauge in collector.collect():
         gauge: SerializedMetric = {
@@ -162,7 +157,6 @@ class MemoryMapCollector(prometheus_client.registry.Collector):
         Initialize.
 
         Arguments:
-
             memory_type: can be rss, pss or size
             pids: the list of pids or none
         """

c2cwsgiutils/pyramid.py

@@ -30,7 +30,6 @@ def includeme(config: pyramid.config.Configurator) -> None:
     Initialize all the pyramid services and event handlers provided by this library.
 
     Arguments:
-
         config: The pyramid Configuration
     """
     logging.captureWarnings(True)

c2cwsgiutils/pyramid_logging.py

@@ -21,7 +21,7 @@ from typing import TYPE_CHECKING, Any, Optional, TextIO
 import cee_syslog_handler
 from pyramid.threadlocal import get_current_request
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 
 class _PyramidFilter(logging.Filter):

c2cwsgiutils/redis_stats.py

@@ -7,8 +7,8 @@ import pyramid.config
 
 from c2cwsgiutils import config_utils, prometheus
 
-LOG = logging.getLogger(__name__)
-ORIG: Optional[Callable[..., Any]] = None
+_LOG = logging.getLogger(__name__)
+_ORIG: Optional[Callable[..., Any]] = None
 
 _PROMETHEUS_REDIS_SUMMARY = prometheus_client.Summary(
     prometheus.build_metric_name("redis"),
@@ -19,9 +19,9 @@ _PROMETHEUS_REDIS_SUMMARY = prometheus_client.Summary(
 
 
 def _execute_command_patch(self: Any, command: str, *args: Any, **options: Any) -> Any:
-    assert ORIG is not None
+    assert _ORIG is not None
     with _PROMETHEUS_REDIS_SUMMARY.labels(command=command).time():
-        return ORIG(self, command, *args, **options)
+        return _ORIG(self, command, *args, **options)
 
 
 def init(config: Optional[pyramid.config.Configurator] = None) -> None:
@@ -32,15 +32,15 @@ def init(config: Optional[pyramid.config.Configurator] = None) -> None:
 
 def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
     """Initialize the Redis tracking."""
-    global ORIG
+    global _ORIG  # pylint: disable=global-statement
     if config_utils.env_or_config(
         config, "C2C_TRACK_REDIS", "c2c.track_redis", True, config_utils.config_bool
     ):
         try:
-            import redis.client
+            import redis.client  # pylint: disable=import-outside-toplevel
 
-            ORIG = redis.client.Redis.execute_command
+            _ORIG = redis.client.Redis.execute_command
             redis.client.Redis.execute_command = _execute_command_patch  # type: ignore
-            LOG.info("Enabled the redis tracking")
+            _LOG.info("Enabled the redis tracking")
         except Exception:  # pragma: nocover  # pylint: disable=broad-except
-            LOG.warning("Cannot enable redis tracking", exc_info=True)
+            _LOG.warning("Cannot enable redis tracking", exc_info=True)

c2cwsgiutils/redis_utils.py

@@ -11,19 +11,19 @@ import yaml
 
 import c2cwsgiutils.config_utils
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 REDIS_URL_KEY = "C2C_REDIS_URL"
-REDIS_OPTIONS_KEY = "C2C_REDIS_OPTIONS"
+_REDIS_OPTIONS_KEY = "C2C_REDIS_OPTIONS"
 REDIS_SENTINELS_KEY = "C2C_REDIS_SENTINELS"
 REDIS_SERVICENAME_KEY = "C2C_REDIS_SERVICENAME"
-REDIS_DB_KEY = "C2C_REDIS_DB"
+_REDIS_DB_KEY = "C2C_REDIS_DB"
 
 REDIS_URL_KEY_PROP = "c2c.redis_url"
-REDIS_OPTIONS_KEY_PROP = "c2c.redis_options"
+_REDIS_OPTIONS_KEY_PROP = "c2c.redis_options"
 REDIS_SENTINELS_KEY_PROP = "c2c.redis_sentinels"
 REDIS_SERVICENAME_KEY_PROP = "c2c.redis_servicename"
-REDIS_DB_KEY_PROP = "c2c.redis_db"
+_REDIS_DB_KEY_PROP = "c2c.redis_db"
 
 _master: Optional["redis.client.Redis[str]"] = None
 _slave: Optional["redis.client.Redis[str]"] = None
@@ -32,7 +32,7 @@ _sentinel: Optional[redis.sentinel.Sentinel] = None
 
 def cleanup() -> None:
     """Cleanup the redis connections."""
-    global _master, _slave, _sentinel
+    global _master, _slave, _sentinel  # pylint: disable=global-statement
     _master = None
     _slave = None
     _sentinel = None
@@ -52,17 +52,17 @@ def get(
 
 
 def _init(settings: Optional[Mapping[str, Any]]) -> None:
-    global _master, _slave, _sentinel
+    global _master, _slave, _sentinel  # pylint: disable=global-statement
     sentinels = c2cwsgiutils.config_utils.env_or_settings(
         settings, REDIS_SENTINELS_KEY, REDIS_SENTINELS_KEY_PROP
     )
     service_name = c2cwsgiutils.config_utils.env_or_settings(
         settings, REDIS_SERVICENAME_KEY, REDIS_SERVICENAME_KEY_PROP
     )
-    db = c2cwsgiutils.config_utils.env_or_settings(settings, REDIS_DB_KEY, REDIS_DB_KEY_PROP)
+    db = c2cwsgiutils.config_utils.env_or_settings(settings, _REDIS_DB_KEY, _REDIS_DB_KEY_PROP)
     url = c2cwsgiutils.config_utils.env_or_settings(settings, REDIS_URL_KEY, REDIS_URL_KEY_PROP)
     redis_options_ = c2cwsgiutils.config_utils.env_or_settings(
-        settings, REDIS_OPTIONS_KEY, REDIS_OPTIONS_KEY_PROP
+        settings, _REDIS_OPTIONS_KEY, _REDIS_OPTIONS_KEY_PROP
     )
 
     redis_options = (
@@ -82,16 +82,16 @@ def _init(settings: Optional[Mapping[str, Any]]) -> None:
             db=db,
             **redis_options,
         )
-        LOG.info("Redis setup using: %s, %s, %s", sentinels, service_name, redis_options_)
+        _LOG.info("Redis setup using: %s, %s, %s", sentinels, service_name, redis_options_)
         _master = _sentinel.master_for(service_name)
         _slave = _sentinel.slave_for(service_name)
         return
     if url:
-        LOG.info("Redis setup using: %s, with options: %s", url, redis_options_)
+        _LOG.info("Redis setup using: %s, with options: %s", url, redis_options_)
         _master = redis.client.Redis.from_url(url, decode_responses=True, **redis_options)
         _slave = _master
     else:
-        LOG.info(
+        _LOG.info(
             "No Redis configuration found, use %s or %s to configure it", REDIS_URL_KEY, REDIS_SENTINELS_KEY
         )
 
@@ -114,22 +114,23 @@ class PubSubWorkerThread(threading.Thread):
             try:
                 pubsub.get_message(ignore_subscribe_messages=True, timeout=1)
                 if not last_was_ok:
-                    LOG.info("Redis is back")
+                    _LOG.info("Redis is back")
                     last_was_ok = True
             except redis.exceptions.RedisError:
                 if last_was_ok:
-                    LOG.warning("Redis connection problem")
+                    _LOG.warning("Redis connection problem")
                 last_was_ok = False
                 time.sleep(0.5)
             except Exception:  # pylint: disable=broad-except
-                LOG.warning("Unexpected error", exc_info=True)
-        LOG.info("Redis subscription worker stopped")
+                _LOG.warning("Unexpected error", exc_info=True)
+        _LOG.info("Redis subscription worker stopped")
         pubsub.close()
         self._running = False
 
     def stop(self) -> None:
-        # stopping simply unsubscribes from all channels and patterns.
-        # the unsubscribe responses that are generated will short circuit
+        """Stop the worker."""
+        # Stopping simply unsubscribes from all channels and patterns.
+        # The unsubscribe responses that are generated will short circuit
         # the loop in run(), calling pubsub.close() to clean up the connection
         self.pubsub.unsubscribe()
         self.pubsub.punsubscribe()

c2cwsgiutils/request_tracking/__init__.py

@@ -20,10 +20,10 @@ from pyramid.threadlocal import get_current_request
 
 from c2cwsgiutils import config_utils, prometheus
 
-ID_HEADERS: list[str] = []
+_ID_HEADERS: list[str] = []
 _HTTPAdapter_send = requests.adapters.HTTPAdapter.send
-LOG = logging.getLogger(__name__)
-DEFAULT_TIMEOUT: Optional[float] = None
+_LOG = logging.getLogger(__name__)
+_DEFAULT_TIMEOUT: Optional[float] = None
 _PROMETHEUS_REQUESTS_SUMMARY = prometheus_client.Summary(
     prometheus.build_metric_name("requests"),
     "Requests requests",
@@ -33,7 +33,7 @@ _PROMETHEUS_REQUESTS_SUMMARY = prometheus_client.Summary(
 
 
 def _gen_request_id(request: pyramid.request.Request) -> str:
-    for id_header in ID_HEADERS:
+    for id_header in _ID_HEADERS:
         if id_header in request.headers:
             return request.headers[id_header]  # type: ignore
     return str(uuid.uuid4())
@@ -50,15 +50,15 @@ def _patch_requests() -> None:
         proxies: Optional[Mapping[str, str]] = None,
     ) -> requests.Response:
         pyramid_request = get_current_request()
-        header = ID_HEADERS[0]
+        header = _ID_HEADERS[0]
         if pyramid_request is not None and header not in request.headers:
             request.headers[header] = pyramid_request.c2c_request_id
 
         if timeout is None:
-            if DEFAULT_TIMEOUT is not None:
-                timeout = DEFAULT_TIMEOUT
+            if _DEFAULT_TIMEOUT is not None:
+                timeout = _DEFAULT_TIMEOUT
             else:
-                LOG.warning("Doing a %s request without timeout to %s", request.method, request.url)
+                _LOG.warning("Doing a %s request without timeout to %s", request.method, request.url)
 
         assert request.url
         parsed = urllib.parse.urlparse(request.url)
@@ -94,20 +94,20 @@ def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
     Use a X-Request-ID (or other) header to track all the logs related to a request
     including on the sub services.
     """
-    global ID_HEADERS, DEFAULT_TIMEOUT
-    ID_HEADERS = ["X-Request-ID", "X-Correlation-ID", "Request-ID", "X-Varnish", "X-Amzn-Trace-Id"]
+    global _ID_HEADERS, _DEFAULT_TIMEOUT  # pylint: disable=global-statement
+    _ID_HEADERS = ["X-Request-ID", "X-Correlation-ID", "Request-ID", "X-Varnish", "X-Amzn-Trace-Id"]
     if config is not None:
         extra_header = config_utils.env_or_config(config, "C2C_REQUEST_ID_HEADER", "c2c.request_id_header")
         if extra_header:
-            ID_HEADERS.insert(0, extra_header)
+            _ID_HEADERS.insert(0, extra_header)
         config.add_request_method(_gen_request_id, "c2c_request_id", reify=True)
 
-    DEFAULT_TIMEOUT = config_utils.env_or_config(
+    _DEFAULT_TIMEOUT = config_utils.env_or_config(
         config, "C2C_REQUESTS_DEFAULT_TIMEOUT", "c2c.requests_default_timeout", type_=float
     )
     _patch_requests()
 
     if config_utils.env_or_config(config, "C2C_SQL_REQUEST_ID", "c2c.sql_request_id", False):
-        from . import _sql
+        from . import _sql  # pylint: disable=import-outside-toplevel
 
         _sql.init()