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

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

c2cwsgiutils/sqlalchemylogger/README.md

@@ -2,22 +2,39 @@ This module is used to ship logging records to an SQL database.
 
 Currently only `sqlite` and `postgres_psycopg2` are fully supported.
 
-To add the logger in a pyramid ini file use something like:
+To add the handler, setup it directly in your app's main function. You
+can add it to an existing logger (setup in you `.ini` file),
+or create a new logger by calling the `logging.getlogger` method.
 
+```python
+import logging
+from c2cwsgiutils.sqlalchemylogger.handlers import SQLAlchemyHandler
+
+def _setup_sqlalchemy_logger():
+    """
+    Setup sqlalchemy logger.
+    """
+    logger = logging.getLogger("A_LOGGER")
+    handler = SQLAlchemyHandler(
+        sqlalchemy_url={
+            # "url": "sqlite:///logger_db.sqlite3",
+            "url": "postgresql://postgres:password@localhost:5432/test",
+            "tablename": "test",
+            "tableargs": {"schema": "xyz"},
+        },
+        does_not_contain_expression="curl",
+    )
+    logger.addHandler(handler)
+
+def main(_, **settings):
+   _setup_sqlalchemy_logger ()
+...
 ```
-[handlers]
-keys = sqlalchemy_logger
-
-[handler_sqlalchemy_logger]
-class = c2cwsgiutils.sqlalchemylogger.handlers.SQLAlchemyHandler
-#args = ({'url':'sqlite:///logger_db.sqlite3','tablename':'test'},'curl')
-args = ({'url':'postgresql://postgres:password@localhost:5432/test','tablename':'test','tableargs': {'schema':'xyz'}},'curl')
-level = NOTSET
-formatter = generic
-propagate = 0
-```
 
-if the credentials given in `args = ` section are sufficient, the handler will
+Do not set up this sqlalchemy logger in you `.ini` file directly.
+It won't work (multi process issue).
+
+if the given credentials are sufficient, the handler will
 create the DB, schema and table it needs directly.
 
 In the above example the second parameter provided `'curl'` is a negative

c2cwsgiutils/sqlalchemylogger/handlers.py

@@ -14,7 +14,7 @@ from sqlalchemy_utils import create_database, database_exists
 from c2cwsgiutils.sqlalchemylogger._filters import ContainsExpression, DoesNotContainExpression
 from c2cwsgiutils.sqlalchemylogger._models import Base, create_log_class
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 
 class SQLAlchemyHandler(logging.Handler):
@@ -30,28 +30,28 @@ class SQLAlchemyHandler(logging.Handler):
         contains_expression: str = "",
     ) -> None:
         super().__init__()
-        # initialize DB session
+        # Initialize DB session
         self.engine = create_engine(sqlalchemy_url["url"])
-        self.Log = create_log_class(
+        self.Log = create_log_class(  # pylint: disable=invalid-name
             tablename=sqlalchemy_url.get("tablename", "logs"),
             tableargs=sqlalchemy_url.get("tableargs", None),  # type: ignore
         )
         Base.metadata.bind = self.engine
         self.session = sessionmaker(bind=self.engine)()  # noqa
-        # initialize log queue
+        # Initialize log queue
         self.log_queue: Any = queue.Queue()
-        # initialize a thread to process the logs Asynchronously
+        # Initialize a thread to process the logs Asynchronously
         self.condition = threading.Condition()
         self.processor_thread = threading.Thread(target=self._processor, daemon=True)
         self.processor_thread.start()
-        # initialize filters
+        # Initialize filters
         if does_not_contain_expression:
             self.addFilter(DoesNotContainExpression(does_not_contain_expression))
         if contains_expression:
             self.addFilter(ContainsExpression(contains_expression))
 
     def _processor(self) -> None:
-        LOG.debug("%s: starting processor thread", __name__)
+        _LOG.debug("%s: starting processor thread", __name__)
         while True:
             logs = []
             time_since_last = time.perf_counter()
@@ -70,7 +70,7 @@ class SQLAlchemyHandler(logging.Handler):
                     ):
                         self._write_logs(logs)
                         break
-        LOG.debug("%s: stopping processor thread", __name__)
+        _LOG.debug("%s: stopping processor thread", __name__)
 
     def _write_logs(self, logs: list[Any]) -> None:
         try:
@@ -85,12 +85,13 @@ class SQLAlchemyHandler(logging.Handler):
             except Exception as e:  # pylint: disable=broad-except
                 # if we really cannot commit the log to DB, do not lock the
                 # thread and do not crash the application
-                LOG.critical(e)
+                _LOG.critical(e)
         finally:
             self.session.expunge_all()
 
     def create_db(self) -> None:
-        LOG.info("%s: creating new database", __name__)
+        """Create the database if it does not exist."""
+        _LOG.info("%s: creating new database", __name__)
         if not database_exists(self.engine.url):
             create_database(self.engine.url)
         # FIXME: we should not access directly the private __table_args__

c2cwsgiutils/stats_pyramid/__init__.py

@@ -10,7 +10,6 @@ from c2cwsgiutils.stats_pyramid import _pyramid_spy
 
 def init(config: pyramid.config.Configurator) -> None:
     """Initialize the whole stats module, for backward compatibility."""
-
     warnings.warn("init function is deprecated; use includeme instead")
     includeme(config)
 
@@ -20,17 +19,14 @@ def includeme(config: pyramid.config.Configurator) -> None:
     Initialize the whole stats pyramid module.
 
     Arguments:
-
         config: The Pyramid config
     """
-
     _pyramid_spy.init(config)
     init_db_spy()
 
 
 def init_db_spy() -> None:
     """Initialize the database spy."""
-
-    from . import _db_spy
+    from . import _db_spy  # pylint: disable=import-outside-toplevel
 
     _db_spy.init()

c2cwsgiutils/stats_pyramid/_db_spy.py

@@ -10,7 +10,7 @@ from sqlalchemy.orm import Session
 
 from c2cwsgiutils import prometheus
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 _PROMETHEUS_DB_SUMMARY = prometheus_client.Summary(
     prometheus.build_metric_name("database"),
@@ -71,7 +71,7 @@ def _create_sqlalchemy_timer_cb(what: str) -> Callable[..., Any]:
 
     def after(*_args: Any, **_kwargs: Any) -> None:
         _PROMETHEUS_DB_SUMMARY.labels({"query": what}).observe(time.perf_counter() - start)
-        LOG.debug("Execute statement '%s' in %d.", what, time.perf_counter() - start)
+        _LOG.debug("Execute statement '%s' in %d.", what, time.perf_counter() - start)
 
     return after
 

c2cwsgiutils/stats_pyramid/_pyramid_spy.py

@@ -86,7 +86,6 @@ def init(config: pyramid.config.Configurator) -> None:  # pragma: nocover
     Subscribe to Pyramid events in order to get some stats on route time execution.
 
     Arguments:
-
         config: The Pyramid config
     """
     config.add_subscriber(_request_callback, pyramid.events.NewRequest)