velocity-python 0.2.5__tar.gz → 0.2.6__tar.gz

{velocity_python-0.2.5/src/velocity_python.egg-info → velocity_python-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.2.5
+Version: 0.2.6
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.2.5 → velocity_python-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.2.5"
+version = "0.2.6"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.2.5 → velocity_python-0.2.6}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.2.5"
+__version__ = version = "0.2.6"
 
 import importlib as _importlib
 

{velocity_python-0.2.5 → velocity_python-0.2.6}/src/velocity/db/core/async_support.py

@@ -528,19 +528,9 @@ class AsyncTransaction:
 
         # R12 — Slow query logging
         if _SLOW_QUERY_MS and elapsed_ms > _SLOW_QUERY_MS:
-            from velocity.db.core.transaction import _summarize_sql
-
-            sql_preview = _summarize_sql(sql)
-            _logger.warning(
-                "Slow async query: %.1f ms sql=%s",
-                elapsed_ms,
-                sql_preview,
-                extra={
-                    "query_duration_ms": round(elapsed_ms, 1),
-                    "sql_preview": sql_preview,
-                },
-                stack_info=True,
-            )
+            from velocity.db.core.transaction import _slow_query_log
+
+            _slow_query_log(_logger, sql, elapsed_ms)
 
         # R14 — N+1 detection / R33 — raw-write cache invalidation
         from velocity.db.core.transaction import _classify_sql, _extract_table_name

{velocity_python-0.2.5 → velocity_python-0.2.6}/src/velocity/db/core/transaction.py

@@ -30,6 +30,15 @@ _DEFAULT_QUERY_CACHE_SIZE = int(os.environ.get("VELOCITY_QUERY_CACHE_SIZE", "100
 # Slow-query threshold in milliseconds (0 = disabled).
 _SLOW_QUERY_MS = int(os.environ.get("VELOCITY_SLOW_QUERY_MS", "500"))
 _SLOW_QUERY_SQL_CHARS = int(os.environ.get("VELOCITY_SLOW_QUERY_SQL_CHARS", "4000"))
+# The slow-query line is for people: this much SQL, the caller's file:line,
+# no traceback unless VELOCITY_SLOW_QUERY_STACK=1 asks for one. The full
+# preview (VELOCITY_SLOW_QUERY_SQL_CHARS) still rides on the record's `extra`.
+_SLOW_QUERY_LINE_CHARS = 200
+_SLOW_QUERY_STACK = os.environ.get("VELOCITY_SLOW_QUERY_STACK", "").strip().lower() in (
+    "1",
+    "true",
+    "yes",
+)
 
 # N+1 detection: warn when the same table is SELECTed more than this many
 # times within a single transaction.  0 = disabled.  Only active when the
@@ -174,16 +183,79 @@ def _written_tables_from_sql(sql):
     return tags or None
 
 
+# a run of three or more bind placeholders: "IN (%s, %s, %s, …)"
+_PLACEHOLDER_RUN_RE = re.compile(r"(%s|\?)(?:\s*,\s*\1){2,}")
+
+
+def _collapse_placeholders(text):
+    """``%s, %s, … (812 of them)`` -> ``%s × 812``."""
+
+    def collapse(match):
+        token = match.group(1)
+        return f"{token} × {match.group(0).count(token)}"
+
+    return _PLACEHOLDER_RUN_RE.sub(collapse, text)
+
+
 def _summarize_sql(sql, limit=None):
     if not sql:
         return None
-    compact = " ".join(str(sql).split())
+    compact = _collapse_placeholders(" ".join(str(sql).split()))
     max_chars = _SLOW_QUERY_SQL_CHARS if limit is None else limit
     if max_chars and len(compact) > max_chars:
         return compact[:max_chars] + "... [truncated]"
     return compact
 
 
+_VELOCITY_DIR = os.path.dirname(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+)
+
+
+def _caller_location():
+    """``file.py:line`` of the first stack frame outside velocity (the code
+    that ran the query), or ``None``."""
+    import traceback
+
+    for frame in reversed(traceback.extract_stack()[:-1]):
+        filename = os.path.abspath(frame.filename)
+        if filename.startswith(_VELOCITY_DIR + os.sep) or "<frozen" in frame.filename:
+            continue
+        return f"{os.path.basename(frame.filename)}:{frame.lineno}"
+    return None
+
+
+def _slow_query_log(logger, sql, elapsed_ms, *, op=None, table=None):
+    """One readable line for a slow query: what, on which table, how long,
+    from where, and the start of the SQL (placeholders collapsed). The fields
+    for log tooling go in ``extra``; a traceback only with
+    VELOCITY_SLOW_QUERY_STACK=1."""
+    op = op or _classify_sql(sql)
+    table = table if table is not None else _extract_table_name(sql)
+    preview = _summarize_sql(sql)
+    line = _summarize_sql(sql, limit=_SLOW_QUERY_LINE_CHARS)
+    caller = _caller_location()
+    took = (
+        f"{elapsed_ms / 1000:.1f} s" if elapsed_ms >= 1000 else f"{elapsed_ms:.0f} ms"
+    )
+    logger.warning(
+        "Slow %s%s: %s%s — %s",
+        op or "query",
+        f" on {table}" if table else "",
+        took,
+        f" at {caller}" if caller else "",
+        line,
+        extra={
+            "query_duration_ms": round(elapsed_ms, 1),
+            "table_name": table,
+            "operation": op,
+            "sql_preview": preview,
+            "caller": caller,
+        },
+        stack_info=_SLOW_QUERY_STACK,
+    )
+
+
 def _is_prepare_kw_type_error(error):
     """True for the TypeError a DB-API driver raises when ``execute()`` has
     no ``prepare`` keyword (``unexpected keyword argument 'prepare'``)."""
@@ -650,23 +722,7 @@ class Transaction:
 
             # R12 — Slow query logging.
             if _SLOW_QUERY_MS and elapsed_ms > _SLOW_QUERY_MS:
-                op = _classify_sql(sql)
-                tbl = _extract_table_name(sql)
-                sql_preview = _summarize_sql(sql)
-                _logger.warning(
-                    "Slow query (%s): %.1f ms table=%s sql=%s",
-                    op,
-                    elapsed_ms,
-                    tbl,
-                    sql_preview,
-                    extra={
-                        "query_duration_ms": round(elapsed_ms, 1),
-                        "table_name": tbl,
-                        "operation": op,
-                        "sql_preview": sql_preview,
-                    },
-                    stack_info=True,
-                )
+                _slow_query_log(_logger, sql, elapsed_ms)
 
             # R14 — N+1 detection (only when debug=True).
             if debug and _N_PLUS_1_THRESHOLD:

{velocity_python-0.2.5 → velocity_python-0.2.6/src/velocity_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.2.5
+Version: 0.2.6
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.2.5 → velocity_python-0.2.6}/tests/test_async_support.py

@@ -728,6 +728,8 @@ class TestAsyncSlowQueryLogging:
                 assert len(slow_calls) >= 1
                 args = slow_calls[0].args
                 kwargs = slow_calls[0].kwargs
-                assert args[2] == "SELECT * FROM large_table"
+                # the same one-line form as the sync path: op, table, SQL last
+                assert args[1:3] == ("SELECT", " on large_table")
+                assert args[-1] == "SELECT * FROM large_table"
                 assert kwargs["extra"]["sql_preview"] == "SELECT * FROM large_table"
-                assert kwargs["stack_info"] is True
+                assert kwargs["stack_info"] is False

{velocity_python-0.2.5 → velocity_python-0.2.6}/tests/test_observability.py

@@ -179,9 +179,14 @@ class TestSlowQueryLogging:
             with caplog.at_level(logging.WARNING, logger="velocity.db.transaction"):
                 tx._execute("SELECT * FROM big_table")
 
-        assert any("Slow query" in r.message for r in caplog.records)
-        assert any("big_table" in r.message for r in caplog.records)
-        assert any("sql=SELECT * FROM big_table" in r.message for r in caplog.records)
+        lines = [
+            r.getMessage() for r in caplog.records if r.getMessage().startswith("Slow ")
+        ]
+        assert len(lines) == 1
+        # one readable line: what, on which table, how long, from where, the SQL
+        assert lines[0].startswith("Slow SELECT on big_table: ")
+        assert " at test_observability.py:" in lines[0]
+        assert lines[0].endswith("— SELECT * FROM big_table")
 
     def test_fast_query_no_warning(self, caplog):
         tx = _make_tx()
@@ -192,7 +197,7 @@ class TestSlowQueryLogging:
             with caplog.at_level(logging.WARNING, logger="velocity.db.transaction"):
                 tx._execute("SELECT 1")
 
-        assert not any("Slow query" in r.message for r in caplog.records)
+        assert not any(r.getMessage().startswith("Slow ") for r in caplog.records)
 
     def test_slow_query_disabled_when_zero(self, caplog):
         tx = _make_tx()
@@ -211,7 +216,7 @@ class TestSlowQueryLogging:
             with caplog.at_level(logging.WARNING, logger="velocity.db.transaction"):
                 tx._execute("SELECT * FROM big_table")
 
-        assert not any("Slow query" in r.message for r in caplog.records)
+        assert not any(r.getMessage().startswith("Slow ") for r in caplog.records)
 
     def test_slow_query_structured_extra(self, caplog):
         """Verify structured logging extra fields on slow-query record."""
@@ -231,13 +236,39 @@ class TestSlowQueryLogging:
             with caplog.at_level(logging.WARNING, logger="velocity.db.transaction"):
                 tx._execute("SELECT * FROM orders WHERE id = 1")
 
-        slow_records = [r for r in caplog.records if "Slow query" in r.message]
+        slow_records = [r for r in caplog.records if r.getMessage().startswith("Slow ")]
         assert len(slow_records) >= 1
         rec = slow_records[0]
         assert rec.query_duration_ms > 0
         assert rec.table_name == "orders"
         assert rec.operation == "SELECT"
         assert rec.sql_preview == "SELECT * FROM orders WHERE id = 1"
+        assert rec.caller.startswith("test_observability.py:")
+        # no traceback unless VELOCITY_SLOW_QUERY_STACK asks for one
+        assert not rec.stack_info
+
+    def test_slow_query_collapses_placeholders_and_can_add_the_stack(self, caplog):
+        tx = _make_tx()
+
+        class SlowCursor:
+            def execute(self, *a, **kw):
+                time.sleep(0.01)
+
+            @property
+            def description(self):
+                return None
+
+        tx.connection.cursor.return_value = SlowCursor()
+        sql = "SELECT * FROM links WHERE event_id IN (" + ", ".join(["%s"] * 812) + ")"
+        with (
+            patch("velocity.db.core.transaction._SLOW_QUERY_MS", 5),
+            patch("velocity.db.core.transaction._SLOW_QUERY_STACK", True),
+        ):
+            with caplog.at_level(logging.WARNING, logger="velocity.db.transaction"):
+                tx._execute(sql, tuple(range(812)))
+
+        rec = [r for r in caplog.records if r.getMessage().startswith("Slow ")][0]
+        assert rec.getMessage().endswith("IN (%s × 812)")
         assert rec.stack_info