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

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()

c2cwsgiutils/request_tracking/_sql.py

@@ -15,5 +15,4 @@ def _add_session_id(session: Session, _transaction: Any) -> None:
 
 def init() -> None:
     """Initialize the SQL alchemy session selector."""
-
     sqlalchemy.event.listen(Session, "after_transaction_create", _add_session_id)

c2cwsgiutils/scripts/genversion.py

@@ -8,9 +8,9 @@ import sys
 import warnings
 from typing import Optional, cast
 
-SRC_VERSION_RE = re.compile(r"^.*\(([^=]*)===?([^=]*)\)$")
-VERSION_RE = re.compile(r"^([^=]*)==([^=]*)$")
-LOG = logging.getLogger(__name__)
+_SRC_VERSION_RE = re.compile(r"^.*\(([^=]*)===?([^=]*)\)$")
+_VERSION_RE = re.compile(r"^([^=]*)==([^=]*)$")
+_LOG = logging.getLogger(__name__)
 
 
 def _get_package_version(comp: str) -> tuple[Optional[str], Optional[str]]:
@@ -19,8 +19,8 @@ def _get_package_version(comp: str) -> tuple[Optional[str], Optional[str]]:
 
     See test_genversion.py for examples.
     """
-    src_matcher = SRC_VERSION_RE.match(comp)
-    matcher = src_matcher or VERSION_RE.match(comp)
+    src_matcher = _SRC_VERSION_RE.match(comp)
+    matcher = src_matcher or _VERSION_RE.match(comp)
     if matcher:
         return cast(tuple[str, str], matcher.groups())
     else:

c2cwsgiutils/scripts/stats_db.py

@@ -6,7 +6,7 @@ import logging
 import os
 import sys
 import time
-from typing import TYPE_CHECKING, Optional
+from typing import Optional
 from wsgiref.simple_server import make_server
 
 import sqlalchemy
@@ -20,12 +20,9 @@ from zope.sqlalchemy import register
 import c2cwsgiutils.setup_process
 from c2cwsgiutils import prometheus
 
-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__)
+_LOG = logging.getLogger(__name__)
 
 
 def _parse_args() -> argparse.Namespace:
@@ -72,6 +69,7 @@ class Reporter:
         self.gauges: dict[str, Gauge] = {}
 
     def get_gauge(self, kind: str, kind_help: str, labels: list[str]) -> Gauge:
+        """Get a gauge."""
         if kind not in self.gauges:
             self.gauges[kind] = Gauge(
                 prometheus.build_metric_name(f"database_{kind}"),
@@ -84,25 +82,30 @@ class Reporter:
     def do_report(
         self, metric: list[str], value: int, kind: str, kind_help: str, tags: dict[str, str]
     ) -> None:
-        LOG.debug("%s.%s -> %d", kind, ".".join(metric), value)
+        """Report a metric."""
+        _LOG.debug("%s.%s -> %d", kind, ".".join(metric), value)
         gauge = self.get_gauge(kind, kind_help, list(tags.keys()))
         gauge.labels(**tags).set(value)
 
     def commit(self) -> None:
+        """Commit the metrics."""
         if self.prometheus_push:
             push_to_gateway(self.args.prometheus_url, job="db_counts", registry=self.registry)
         else:
             port = int(os.environ.get("C2C_PROMETHEUS_PORT", "9090"))
             app = make_wsgi_app(self.registry)
             with make_server("", port, app) as httpd:
-                LOG.info("Waiting that Prometheus get the metrics served on port %s...", port)
+                _LOG.info("Waiting that Prometheus get the metrics served on port %s...", port)
                 httpd.handle_request()
 
     def error(self, metric: list[str], error_: Exception) -> None:
+        """Report an error."""
+        del metric
         if self._error is None:
             self._error = error_
 
     def report_error(self) -> None:
+        """Raise the error if any."""
         if self._error is not None:
             raise self._error
 
@@ -225,7 +228,6 @@ def _do_table_count(
 
 def do_extra(session: scoped_session, sql: str, kind: str, gauge_help: str, reporter: Reporter) -> None:
     """Do an extra report."""
-
     for metric, count in session.execute(sqlalchemy.text(sql)):
         reporter.do_report(
             str(metric).split("."), count, kind=kind, kind_help=gauge_help, tags={"metric": metric}
@@ -253,29 +255,29 @@ def _do_dtats_db(args: argparse.Namespace) -> None:
         params={"schemas": tuple(args.schema)},
     ).fetchall()
     for schema, table in tables:
-        LOG.info("Process table %s.%s.", schema, table)
+        _LOG.info("Process table %s.%s.", schema, table)
         try:
             do_table(session, schema, table, reporter)
         except Exception as e:  # pylint: disable=broad-except
-            LOG.exception("Process table %s.%s error.", schema, table)
+            _LOG.exception("Process table %s.%s error.", schema, table)
             reporter.error([schema, table], e)
 
     if args.extra:
         for pos, extra in enumerate(args.extra):
-            LOG.info("Process extra %s.", extra)
+            _LOG.info("Process extra %s.", extra)
             try:
                 do_extra(session, extra, "extra", "Extra metric", reporter)
             except Exception as e:  # pylint: disable=broad-except
-                LOG.exception("Process extra %s error.", extra)
+                _LOG.exception("Process extra %s error.", extra)
                 reporter.error(["extra", str(pos + 1)], e)
     if args.extra_gauge:
         for pos, extra in enumerate(args.extra_gauge):
             sql, gauge, gauge_help = extra
-            LOG.info("Process extra %s.", extra)
+            _LOG.info("Process extra %s.", extra)
             try:
                 do_extra(session, sql, gauge, gauge_help, reporter)
             except Exception as e:  # pylint: disable=broad-except
-                LOG.exception("Process extra %s error.", extra)
+                _LOG.exception("Process extra %s error.", extra)
                 reporter.error(["extra", str(len(args.extra) + pos + 1)], e)
 
     reporter.commit()
@@ -294,11 +296,11 @@ def main() -> None:
             success = True
             break
         except:  # pylint: disable=bare-except
-            LOG.exception("Exception during run")
+            _LOG.exception("Exception during run")
         time.sleep(float(os.environ.get("C2CWSGIUTILS_STATS_DB_SLEEP", 1)))
 
     if not success:
-        LOG.error("Not in success, exiting")
+        _LOG.error("Not in success, exiting")
         sys.exit(1)
 
 

c2cwsgiutils/scripts/test_print.py

@@ -8,7 +8,7 @@ import warnings
 import c2cwsgiutils.setup_process
 from c2cwsgiutils.acceptance.print import PrintConnection
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 
 def _parse_args() -> argparse.Namespace:
@@ -38,7 +38,7 @@ def main() -> None:
     if args.app is None:
         for app in print_.get_apps():
             if app != "default":
-                LOG.info("\n\n%s=================", app)
+                _LOG.info("\n\n%s=================", app)
                 test_app(print_, app)
     else:
         test_app(print_, args.app)
@@ -47,13 +47,13 @@ def main() -> None:
 def test_app(print_: PrintConnection, app: str) -> None:
     """Test the application."""
     capabilities = print_.get_capabilities(app)
-    LOG.debug("Capabilities:\n%s", pprint.pformat(capabilities))
+    _LOG.debug("Capabilities:\n%s", pprint.pformat(capabilities))
     examples = print_.get_example_requests(app)
     for name, request in examples.items():
-        LOG.info("\n%s-----------------", name)
+        _LOG.info("\n%s-----------------", name)
         pdf = print_.get_pdf(app, request)
         size = len(pdf.content)
-        LOG.info("Size=%d", size)
+        _LOG.info("Size=%d", size)
 
 
 if __name__ == "__main__":

c2cwsgiutils/sentry.py

@@ -6,7 +6,8 @@ from collections.abc import Generator, MutableMapping
 from typing import Any, Callable, Optional
 
 import pyramid.config
-import sentry_sdk
+import sentry_sdk.integrations
+from sentry_sdk.integrations.asyncio import AsyncioIntegration
 from sentry_sdk.integrations.logging import LoggingIntegration, ignore_logger
 from sentry_sdk.integrations.pyramid import PyramidIntegration
 from sentry_sdk.integrations.redis import RedisIntegration
@@ -15,14 +16,15 @@ from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
 
 from c2cwsgiutils import config_utils
 
-LOG = logging.getLogger(__name__)
-_client_setup = False
+_LOG = logging.getLogger(__name__)
+_CLIENT_SETUP = False
 
 
 def _create_before_send_filter(tags: MutableMapping[str, str]) -> Callable[[Any, Any], Any]:
     """Create a filter that adds tags to every events."""
 
     def do_filter(event: Any, hint: Any) -> Any:
+        del hint
         event.setdefault("tags", {}).update(tags)
         return event
 
@@ -31,17 +33,15 @@ def _create_before_send_filter(tags: MutableMapping[str, str]) -> Callable[[Any,
 
 def init(config: Optional[pyramid.config.Configurator] = None) -> None:
     """Initialize the Sentry integration, for backward compatibility."""
-
     warnings.warn("init function is deprecated; use includeme instead")
     includeme(config)
 
 
 def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
     """Initialize the Sentry integration."""
-
-    global _client_setup
+    global _CLIENT_SETUP  # pylint: disable=global-statement
     sentry_url = config_utils.env_or_config(config, "SENTRY_URL", "c2c.sentry.url")
-    if sentry_url is not None and not _client_setup:
+    if sentry_url is not None and not _CLIENT_SETUP:
         client_info: MutableMapping[str, Any] = {
             key[14:].lower(): value for key, value in os.environ.items() if key.startswith("SENTRY_CLIENT_")
         }
@@ -55,6 +55,7 @@ def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
             "propagate_traces",
             "auto_enabling_integrations",
             "auto_session_tracking",
+            "enable_tracing",
         ):
             if key in client_info:
                 client_info[key] = client_info[key].lower() in ("1", "t", "true")
@@ -73,25 +74,58 @@ def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
         client_info["ignore_errors"] = client_info.pop("ignore_exceptions", "SystemExit").split(",")
         tags = {key[11:].lower(): value for key, value in os.environ.items() if key.startswith("SENTRY_TAG_")}
 
-        sentry_logging = LoggingIntegration(
-            level=logging.DEBUG,
-            event_level=config_utils.env_or_config(
-                config, "SENTRY_LEVEL", "c2c.sentry_level", "ERROR"
-            ).upper(),
-        )
         traces_sample_rate = float(
             config_utils.env_or_config(
                 config, "SENTRY_TRACES_SAMPLE_RATE", "c2c.sentry_traces_sample_rate", "0.0"
             )
         )
+        integrations: list[sentry_sdk.integrations.Integration] = []
+        if config_utils.config_bool(
+            config_utils.env_or_config(
+                config, "SENTRY_INTEGRATION_LOGGING", "c2c.sentry_integration_logging", "true"
+            )
+        ):
+            integrations.append(
+                LoggingIntegration(
+                    level=logging.DEBUG,
+                    event_level=config_utils.env_or_config(
+                        config, "SENTRY_LEVEL", "c2c.sentry_level", "ERROR"
+                    ).upper(),
+                )
+            )
+        if config_utils.config_bool(
+            config_utils.env_or_config(
+                config, "SENTRY_INTEGRATION_PYRAMID", "c2c.sentry_integration_pyramid", "true"
+            )
+        ):
+            integrations.append(PyramidIntegration())
+        if config_utils.config_bool(
+            config_utils.env_or_config(
+                config, "SENTRY_INTEGRATION_SQLALCHEMY", "c2c.sentry_integration_sqlalchemy", "true"
+            )
+        ):
+            integrations.append(SqlalchemyIntegration())
+        if config_utils.config_bool(
+            config_utils.env_or_config(
+                config, "SENTRY_INTEGRATION_REDIS", "c2c.sentry_integration_redis", "true"
+            )
+        ):
+            integrations.append(RedisIntegration())
+        if config_utils.config_bool(
+            config_utils.env_or_config(
+                config, "SENTRY_INTEGRATION_ASYNCIO", "c2c.sentry_integration_asyncio", "true"
+            )
+        ):
+            integrations.append(AsyncioIntegration())
+
         sentry_sdk.init(
             dsn=sentry_url,
-            integrations=[sentry_logging, PyramidIntegration(), SqlalchemyIntegration(), RedisIntegration()],
+            integrations=integrations,
             traces_sample_rate=traces_sample_rate,
             before_send=_create_before_send_filter(tags),
             **client_info,
         )
-        _client_setup = True
+        _CLIENT_SETUP = True
 
         excludes = config_utils.env_or_config(
             config, "SENTRY_EXCLUDES", "c2c.sentry.excludes", "sentry_sdk"
@@ -99,7 +133,7 @@ def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
         for exclude in excludes:
             ignore_logger(exclude)
 
-        LOG.info("Configured sentry reporting with client=%s and tags=%s", repr(client_info), repr(tags))
+        _LOG.info("Configured sentry reporting with client=%s and tags=%s", repr(client_info), repr(tags))
 
 
 @contextlib.contextmanager
@@ -110,7 +144,7 @@ def capture_exceptions() -> Generator[None, None, None]:
     You don't need to use that for exception terminating the process (those not caught). Sentry does that
     already.
     """
-    if _client_setup:
+    if _CLIENT_SETUP:
         try:
             yield
         except Exception:
@@ -122,12 +156,12 @@ def capture_exceptions() -> Generator[None, None, None]:
 
 def filter_wsgi_app(application: Callable[..., Any]) -> Callable[..., Any]:
     """If sentry is configured, add a Sentry filter around the application."""
-    if _client_setup:
+    if _CLIENT_SETUP:
         try:
-            LOG.info("Enable WSGI filter for Sentry")
+            _LOG.info("Enable WSGI filter for Sentry")
             return SentryWsgiMiddleware(application)
         except Exception:  # pylint: disable=broad-except
-            LOG.error("Failed enabling sentry. Continuing without it.", exc_info=True)
+            _LOG.error("Failed enabling sentry. Continuing without it.", exc_info=True)
             return application
     else:
         return application
@@ -135,4 +169,5 @@ def filter_wsgi_app(application: Callable[..., Any]) -> Callable[..., Any]:
 
 def filter_factory(*args: Any, **kwargs: Any) -> Callable[..., Any]:
     """Get the filter."""
+    del args, kwargs
     return filter_wsgi_app

c2cwsgiutils/services.py

@@ -5,7 +5,7 @@ from cornice import Service
 from pyramid.request import Request
 from pyramid.response import Response
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 
 def create(name: str, path: str, *args: Any, **kwargs: Any) -> Service:
@@ -31,6 +31,6 @@ def _cache_cors(response: Response, request: Request) -> Response:
     except Exception:
         # cornice catches exceptions from filters, and tries call back the filter with only the request.
         # This leads to a useless message in case of error...
-        LOG.error("Failed fixing cache headers for CORS", exc_info=True)
+        _LOG.error("Failed fixing cache headers for CORS", exc_info=True)
         raise
     return response

c2cwsgiutils/setup_process.py

@@ -24,7 +24,6 @@ def fill_arguments(
     default_config_uri: str = "c2c:///app/production.ini",
 ) -> None:
     """Add the needed arguments to the parser like it's done in pshell."""
-
     parser.add_argument(
         "--config-uri" if use_attribute else "config_uri",
         nargs="?",

c2cwsgiutils/sql_profiler/__init__.py

@@ -11,10 +11,9 @@ import pyramid.request
 
 from c2cwsgiutils import auth
 
-ENV_KEY = "C2C_SQL_PROFILER_ENABLED"
-CONFIG_KEY = "c2c.sql_profiler_enabled"
-LOG = logging.getLogger(__name__)
-repository = None
+_ENV_KEY = "C2C_SQL_PROFILER_ENABLED"
+_CONFIG_KEY = "c2c.sql_profiler_enabled"
+_LOG = logging.getLogger(__name__)
 
 
 def init(config: pyramid.config.Configurator) -> None:
@@ -25,7 +24,7 @@ def init(config: pyramid.config.Configurator) -> None:
 
 def includeme(config: pyramid.config.Configurator) -> None:
     """Install a pyramid  event handler that adds the request information."""
-    if auth.is_enabled(config, ENV_KEY, CONFIG_KEY):
-        from . import _impl
+    if auth.is_enabled(config, _ENV_KEY, _CONFIG_KEY):
+        from . import _impl  # pylint: disable=import-outside-toplevel
 
         _impl.init(config)

c2cwsgiutils/sql_profiler/_impl.py

@@ -16,8 +16,8 @@ import sqlalchemy.event
 
 from c2cwsgiutils import auth, broadcast, config_utils
 
-LOG = logging.getLogger(__name__)
-repository = None
+_LOG = logging.getLogger(__name__)
+_REPOSITORY = None
 
 
 class _Repository:
@@ -35,7 +35,8 @@ class _Repository:
         _context: Any,
         _executemany: Any,
     ) -> None:
-        if statement.startswith("SELECT ") and LOG.isEnabledFor(logging.INFO):
+        """Profile the SQL statement."""
+        if statement.startswith("SELECT ") and _LOG.isEnabledFor(logging.INFO):
             do_it = False
             with self._lock:
                 if statement not in self._repo:
@@ -43,8 +44,8 @@ class _Repository:
                     self._repo.add(statement)
             if do_it:
                 try:
-                    LOG.info("statement:\n%s", _indent(_beautify_sql(statement)))
-                    LOG.info("parameters: %s", repr(parameters))
+                    _LOG.info("statement:\n%s", _indent(_beautify_sql(statement)))
+                    _LOG.info("parameters: %s", repr(parameters))
                     with conn.engine.begin() as c:
                         output = "\n  ".join(
                             [
@@ -54,7 +55,7 @@ class _Repository:
                                 )
                             ]
                         )
-                    LOG.info(output)
+                    _LOG.info(output)
                 except Exception:  # nosec  # pylint: disable=broad-except
                     pass
 
@@ -64,21 +65,21 @@ def _sql_profiler_view(request: pyramid.request.Request) -> Mapping[str, Any]:
     enable = request.params.get("enable")
     if enable is not None:
         broadcast.broadcast("c2c_sql_profiler", params={"enable": enable}, expect_answers=True)
-    return {"status": 200, "enabled": repository is not None}
+    return {"status": 200, "enabled": _REPOSITORY is not None}
 
 
 def _setup_profiler(enable: str) -> None:
-    global repository
+    global _REPOSITORY  # pylint: disable=global-statement
     if config_utils.config_bool(enable):
-        if repository is None:
-            LOG.info("Enabling the SQL profiler")
-            repository = _Repository()
-            sqlalchemy.event.listen(sqlalchemy.engine.Engine, "before_cursor_execute", repository.profile)
+        if _REPOSITORY is None:
+            _LOG.info("Enabling the SQL profiler")
+            _REPOSITORY = _Repository()
+            sqlalchemy.event.listen(sqlalchemy.engine.Engine, "before_cursor_execute", _REPOSITORY.profile)
     else:
-        if repository is not None:
-            LOG.info("Disabling the SQL profiler")
-            sqlalchemy.event.remove(sqlalchemy.engine.Engine, "before_cursor_execute", repository.profile)
-            repository = None
+        if _REPOSITORY is not None:
+            _LOG.info("Disabling the SQL profiler")
+            sqlalchemy.event.remove(sqlalchemy.engine.Engine, "before_cursor_execute", _REPOSITORY.profile)
+            _REPOSITORY = None
 
 
 def _beautify_sql(statement: str) -> str:
@@ -102,4 +103,4 @@ def init(config: pyramid.config.Configurator) -> None:
         "c2c_sql_profiler", config_utils.get_base_path(config) + r"/sql_profiler", request_method="GET"
     )
     config.add_view(_sql_profiler_view, route_name="c2c_sql_profiler", renderer="fast_json", http_cache=0)
-    LOG.info("Enabled the /sql_profiler API")
+    _LOG.info("Enabled the /sql_profiler API")