c2cwsgiutils 6.1.0.dev105__py3-none-any.whl → 6.1.7__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,17 +113,29 @@ 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()
     if type_ is None:
         if isinstance(value, int):
             type_ = "number"
+        elif isinstance(value, bool):
+            type_ = "checkbox"
         else:
             type_ = "text"
+    if type_ == "checkbox":
+        checked = " checked" if value else ""
+        return f"""
+<div class="form-check">
+  <input class="form-check-input" type="checkbox" name="{name}" value="true" id="{id_}"{checked}>
+  <label class="form-check-label" for="{id_}">
+    {label}
+  </label>
+</div>"""
+
     result = ""
     if label is not None:
         result += f'<div class="row mb-3"><label class="col-sm-2 col-form-label" for="{id_}">{label}</label>'
@@ -138,7 +150,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 +164,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)
@@ -202,7 +213,7 @@ def _index(request: pyramid.request.Request) -> dict[str, str]:
 def _versions(request: pyramid.request.Request) -> str:
     versions_url = _url(request, "c2c_versions")
     if versions_url:
-        return section("Versions", paragraph(link(versions_url, "Get")), sep=False)
+        return section("Versions " + link(versions_url, "Get"), sep=False)
     else:
         return ""
 
@@ -281,6 +292,7 @@ def _logging(request: pyramid.request.Request) -> str:
 def _debug(request: pyramid.request.Request) -> str:
     dump_memory_url = _url(request, "c2c_debug_memory")
     if dump_memory_url:
+        as_dot = 'as <a href="https://graphviz.org/">dot diagram</a>, can be open with <a href="https://pypi.org/project/xdot/">xdot</a>'
         return section(
             " ".join(
                 [
@@ -290,32 +302,42 @@ def _debug(request: pyramid.request.Request) -> str:
                     link(_url(request, "c2c_debug_memory_maps"), "Mapped memory"),
                 ]
             ),
+            '<h2>Memory usage<span style="font-size: 0.5em;">, with <a href="https://mg.pov.lt/objgraph/">objgraph</a></span></h2>',
+            "<p>Runs the garbage collector and dumps the memory usage as JSON.</p>",
             form(
                 dump_memory_url,
                 input_("limit", value=30),
                 input_("analyze_type"),
+                input_("python_internals_map", type_="checkbox"),
                 button("Dump memory usage"),
             ),
+            f"<p>Runs the garbage collector and dumps the memory refs {as_dot}.</p>",
             form(
                 _url(request, "c2c_debug_show_refs"),
                 input_("analyze_type", value="gunicorn.app.wsgiapp.WSGIApplication"),
-                input_("max_depth", value=3),
-                input_("too_many", value=10),
+                input_("analyze_id", type_="number"),
+                input_("max_depth", type_="number", value=3),
+                input_("too_many", type_="number", value=10),
                 input_("min_size_kb", type_="number"),
                 button("Object refs"),
             ),
+            "<p>Runs the garbage collector, query the path, runs the garbage collector again, get the memory diff as JSON.</p>",
             form(
                 _url(request, "c2c_debug_memory_diff"),
                 input_("path"),
                 input_("limit", value=30),
+                input_("no_warmup", type_="checkbox"),
                 button("Memory diff"),
             ),
+            "<h2>Sleep</h2>",
             form(
                 _url(request, "c2c_debug_sleep"),
                 input_("time", value=1),
                 button("Sleep"),
             ),
-            form(_url(request, "c2c_debug_time"), button("Time")),
+            "<h2>Server times</h2>",
+            form(_url(request, "c2c_debug_time"), button("Get")),
+            "<h2>HTTP error</h2>",
             form(
                 _url(request, "c2c_debug_error"),
                 input_("status", value=500),
@@ -346,7 +368,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 +521,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

@@ -3,9 +3,9 @@ from typing import Optional, cast
 
 from plaster_pastedeploy import Loader as BaseLoader
 
-from c2cwsgiutils import get_config_defaults
+from c2cwsgiutils import get_config_defaults, get_logconfig_dict
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 
 class Loader(BaseLoader):  # type: ignore
@@ -19,3 +19,22 @@ class Loader(BaseLoader):  # type: ignore
     def __repr__(self) -> str:
         """Get the object representation."""
         return f'c2cwsgiutils.loader.Loader(uri="{self.uri}")'
+
+    def setup_logging(self, defaults: Optional[dict[str, str]] = None) -> None:
+        """
+        Set up logging via :func:`logging.config.dictConfig` with value returned from c2cwsgiutils.get_logconfig_dict.
+
+        Defaults are specified for the special ``__file__`` and ``here``
+        variables, similar to PasteDeploy config loading. Extra defaults can
+        optionally be specified as a dict in ``defaults``.
+
+        Arguments:
+        ---------
+        defaults: The defaults that will be used when passed to
+            :func:`logging.config.fileConfig`.
+
+        """
+        if "loggers" in self.get_sections():
+            logging.config.dictConfig(get_logconfig_dict(self.uri.path))
+        else:
+            logging.basicConfig()

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

@@ -1,5 +1,6 @@
 """Every thing we needs to have the metrics in Prometheus."""
 
+import logging
 import os
 import re
 from collections.abc import Generator, Iterable
@@ -11,10 +12,12 @@ import prometheus_client.metrics_core
 import prometheus_client.multiprocess
 import prometheus_client.registry
 import pyramid.config
+import redis.exceptions
 
 from c2cwsgiutils import broadcast, redis_utils
 from c2cwsgiutils.debug.utils import dump_memory_maps
 
+_LOG = logging.getLogger(__name__)
 _NUMBER_RE = re.compile(r"^[0-9]+$")
 MULTI_PROCESS_COLLECTOR_BROADCAST_CHANNELS = [
     "c2cwsgiutils_prometheus_collector_gc",
@@ -24,7 +27,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 +40,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 +74,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 +84,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 = {
@@ -122,9 +120,12 @@ class MultiProcessCustomCollector(prometheus_client.registry.Collector):
     def collect(self) -> Generator[prometheus_client.core.Metric, None, None]:
         results: list[list[SerializedMetric]] = []
         for channel in MULTI_PROCESS_COLLECTOR_BROADCAST_CHANNELS:
-            result = broadcast.broadcast(channel, expect_answers=True)
-            if result is not None:
-                results.extend(cast(Iterable[list[SerializedMetric]], result))
+            try:
+                result = broadcast.broadcast(channel, expect_answers=True)
+                if result is not None:
+                    results.extend(cast(Iterable[list[SerializedMetric]], result))
+            except redis.exceptions.ConnectionError:
+                _LOG.error("Failed to get the metrics from the other processes")
         return _deserialize_collected_data(results)
 
 
@@ -162,7 +163,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)