wrapture-instrumentation-postgresql 1.0.0.dev1__tar.gz → 1.0.0.dev2__tar.gz

{wrapture_instrumentation_postgresql-1.0.0.dev1 → wrapture_instrumentation_postgresql-1.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wrapture-instrumentation-postgresql
-Version: 1.0.0.dev1
+Version: 1.0.0.dev2
 Summary: Instrumentation for the PostgreSQL client libraries (psycopg, psycopg2, asyncpg), applied through wrapture.
 Author-email: Graham Dumpleton <Graham.Dumpleton@gmail.com>
 License-Expression: BSD-2-Clause
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: wrapture>=1.0.0a20
+Requires-Dist: wrapture>=1.0.0a21
 Dynamic: license-file
 
 # wrapture-instrumentation-postgresql
@@ -109,7 +109,7 @@ $ python -m wrapture.tools instrumentation --verbose
 | ------ | ------------------ | ------- | -------- |
 | [`psycopg`](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/src/wrapture_instrumentation_postgresql/psycopg/README.md) | psycopg 3.1+ (3.x) | Every query as one `database` leaf, however it was issued (a cursor's `execute` or `executemany`, the connection's shortcut, a streamed query, a COPY, a server-side cursor's DECLARE), plus the connection being opened and each transaction boundary (`commit`, `rollback`, the connection's context manager, and a `transaction()` block's begin and end, savepoints included); sync and async classes alike, and connections from a pool. Each event carries the system, the operation, and the database, host and port it reached; a failing statement records the driver's exception. The SQL text is recorded only with the `statement` setting on, bound parameters never. | `statement` |
 | [`psycopg2`](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/src/wrapture_instrumentation_postgresql/psycopg2/README.md) | psycopg2 2.9+ (2.x), psycopg2-binary alike | Every query as one `database` leaf, however it was issued (`execute`, `executemany`, `callproc`, the extras' batch helpers, a named cursor's DECLARE), each COPY (`copy_from`, `copy_to`, `copy_expert`), the connection being opened and each transaction boundary (`commit`, `rollback`, the connection's context manager); through recording subclasses injected by psycopg2's own factory mechanism, so your `cursor_factory` and `connection_factory` classes keep working and are recorded too. Each event carries the system, the operation, and the database, host and port it reached; a failing statement records the driver's exception. The SQL text (the template with its placeholders) is recorded only with the `statement` setting on, bound parameters never. | `statement` |
-| [`asyncpg`](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/src/wrapture_instrumentation_postgresql/asyncpg/README.md) | asyncpg 0.29+ (0.x) | Every query as one `database` leaf recorded around its await, however it was issued (a connection's `execute`, `executemany`, `fetch`, `fetchrow`, `fetchval` or `fetchmany`, a prepared statement's own fetches, a server-side cursor's DECLARE and each FETCH), each COPY, the connection being opened, and each transaction boundary, which asyncpg issues through `execute`. Each event carries the system, the operation, and the database, host and port it reached; a failing statement records the driver's exception. The SQL text (with its `$n` placeholders) is recorded only with the `statement` setting on, query arguments never. A connection taken from a pool does not yet record its queries (a wrapture fix is pending). | `statement` |
+| [`asyncpg`](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/src/wrapture_instrumentation_postgresql/asyncpg/README.md) | asyncpg 0.29+ (0.x) | Every query as one `database` leaf recorded around its await, however it was issued (a connection's `execute`, `executemany`, `fetch`, `fetchrow`, `fetchval` or `fetchmany`, a prepared statement's own fetches, a server-side cursor's DECLARE and each FETCH), each COPY, the connection being opened, and each transaction boundary, which asyncpg issues through `execute`. Each event carries the system, the operation, and the database, host and port it reached; a failing statement records the driver's exception. The SQL text (with its `$n` placeholders) is recorded only with the `statement` setting on, query arguments never. A connection taken from a pool records its queries like any other. | `statement` |
 
 The entry point name is the config's `name`""; the linked per-target
 README is the full user documentation: what records, what the events
@@ -127,11 +127,6 @@ By design, and where it goes:
   records its queries like any other, but taking and returning it are
   not database operations and are not recorded.
 
-- A connection taken from an asyncpg pool does not yet record its
-  queries: the pool proxy calls the connection's methods through the
-  class, a calling convention wrapture's signature check does not
-  yet handle. The fix is on wrapture's side.
-
 - LISTEN/NOTIFY, large objects and two-phase commit are out of scope.
 
 ## Adding a target

{wrapture_instrumentation_postgresql-1.0.0.dev1 → wrapture_instrumentation_postgresql-1.0.0.dev2}/README.md

@@ -86,7 +86,7 @@ $ python -m wrapture.tools instrumentation --verbose
 | ------ | ------------------ | ------- | -------- |
 | [`psycopg`](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/src/wrapture_instrumentation_postgresql/psycopg/README.md) | psycopg 3.1+ (3.x) | Every query as one `database` leaf, however it was issued (a cursor's `execute` or `executemany`, the connection's shortcut, a streamed query, a COPY, a server-side cursor's DECLARE), plus the connection being opened and each transaction boundary (`commit`, `rollback`, the connection's context manager, and a `transaction()` block's begin and end, savepoints included); sync and async classes alike, and connections from a pool. Each event carries the system, the operation, and the database, host and port it reached; a failing statement records the driver's exception. The SQL text is recorded only with the `statement` setting on, bound parameters never. | `statement` |
 | [`psycopg2`](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/src/wrapture_instrumentation_postgresql/psycopg2/README.md) | psycopg2 2.9+ (2.x), psycopg2-binary alike | Every query as one `database` leaf, however it was issued (`execute`, `executemany`, `callproc`, the extras' batch helpers, a named cursor's DECLARE), each COPY (`copy_from`, `copy_to`, `copy_expert`), the connection being opened and each transaction boundary (`commit`, `rollback`, the connection's context manager); through recording subclasses injected by psycopg2's own factory mechanism, so your `cursor_factory` and `connection_factory` classes keep working and are recorded too. Each event carries the system, the operation, and the database, host and port it reached; a failing statement records the driver's exception. The SQL text (the template with its placeholders) is recorded only with the `statement` setting on, bound parameters never. | `statement` |
-| [`asyncpg`](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/src/wrapture_instrumentation_postgresql/asyncpg/README.md) | asyncpg 0.29+ (0.x) | Every query as one `database` leaf recorded around its await, however it was issued (a connection's `execute`, `executemany`, `fetch`, `fetchrow`, `fetchval` or `fetchmany`, a prepared statement's own fetches, a server-side cursor's DECLARE and each FETCH), each COPY, the connection being opened, and each transaction boundary, which asyncpg issues through `execute`. Each event carries the system, the operation, and the database, host and port it reached; a failing statement records the driver's exception. The SQL text (with its `$n` placeholders) is recorded only with the `statement` setting on, query arguments never. A connection taken from a pool does not yet record its queries (a wrapture fix is pending). | `statement` |
+| [`asyncpg`](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/src/wrapture_instrumentation_postgresql/asyncpg/README.md) | asyncpg 0.29+ (0.x) | Every query as one `database` leaf recorded around its await, however it was issued (a connection's `execute`, `executemany`, `fetch`, `fetchrow`, `fetchval` or `fetchmany`, a prepared statement's own fetches, a server-side cursor's DECLARE and each FETCH), each COPY, the connection being opened, and each transaction boundary, which asyncpg issues through `execute`. Each event carries the system, the operation, and the database, host and port it reached; a failing statement records the driver's exception. The SQL text (with its `$n` placeholders) is recorded only with the `statement` setting on, query arguments never. A connection taken from a pool records its queries like any other. | `statement` |
 
 The entry point name is the config's `name`""; the linked per-target
 README is the full user documentation: what records, what the events
@@ -104,11 +104,6 @@ By design, and where it goes:
   records its queries like any other, but taking and returning it are
   not database operations and are not recorded.
 
-- A connection taken from an asyncpg pool does not yet record its
-  queries: the pool proxy calls the connection's methods through the
-  class, a calling convention wrapture's signature check does not
-  yet handle. The fix is on wrapture's side.
-
 - LISTEN/NOTIFY, large objects and two-phase commit are out of scope.
 
 ## Adding a target

{wrapture_instrumentation_postgresql-1.0.0.dev1 → wrapture_instrumentation_postgresql-1.0.0.dev2}/pyproject.toml

@@ -28,7 +28,7 @@ classifiers = [
 # install psycopg, and whether a driver is present and at a supported
 # version is checked by wrapture at apply time from the class data.
 dependencies = [
-    "wrapture>=1.0.0a20",
+    "wrapture>=1.0.0a21",
 ]
 
 [project.urls]

{wrapture_instrumentation_postgresql-1.0.0.dev1 → wrapture_instrumentation_postgresql-1.0.0.dev2}/src/wrapture_instrumentation_postgresql/__init__.py

@@ -22,5 +22,5 @@ def _format_version(parts: tuple[str, ...]) -> str:
     )
 
 
-__version_info__ = ("1", "0", "0", "dev1")
+__version_info__ = ("1", "0", "0", "dev2")
 __version__ = _format_version(__version_info__)

{wrapture_instrumentation_postgresql-1.0.0.dev1 → wrapture_instrumentation_postgresql-1.0.0.dev2}/src/wrapture_instrumentation_postgresql/asyncpg/README.md

@@ -90,7 +90,9 @@ asyncpg.prepared_stmt:PreparedStatement.fetchval(args='<1 values>', column=0, ti
   (`asyncpg.UndefinedTableError`, say) on the event as it escapes; a
   timeout or cancellation arrives the same way. A pool made after the
   instrumentation is applied opens its connections through the
-  bound `connect`, on the task that awaited it, so those record too.
+  bound `connect`, on the task that awaited it, so those record too,
+  and a connection taken from the pool (`async with pool.acquire()
+  as conn:`) records its queries like one you opened yourself.
 
 ## Settings
 
@@ -118,16 +120,6 @@ prepared statement's own fetch, and the commit's `execute` beneath
 level either way, and the dialect's setup queries show up beside the
 tree regardless, since they run outside the recorded seams.
 
-## Known gap
-
-A connection taken from a pool (`async with pool.acquire() as conn:`)
-does not yet record its queries: asyncpg's pool proxy calls the
-connection's methods through the class, `Connection.fetchval(
-connection, query)`, a calling convention wrapture's signature check
-does not yet handle. A fix is on wrapture's side and this note goes
-when it lands. The pool's connects record, and so does everything on
-a connection you opened yourself.
-
 ## How it patches
 
 For the implementation detail see the module docstrings of

{wrapture_instrumentation_postgresql-1.0.0.dev1 → wrapture_instrumentation_postgresql-1.0.0.dev2}/src/wrapture_instrumentation_postgresql/asyncpg/connection.py

@@ -167,19 +167,8 @@ def instrument(module: Any, instrumentation: wrapture.Instrumentation) -> None:
         wrapped: Any, instance: Any, args: tuple[Any, ...], kwargs: dict[str, Any]
     ) -> Any:
         async def record() -> Any:
-            data = data_for(instance, query_of(args, kwargs), "COPY")
-            wrapture.annotate(**data)
-
-            # With arguments, asyncpg renders them into the query
-            # through a SELECT on this same connection before the COPY:
-            # a bound call beneath this leaf, silenced, whose own
-            # annotation would otherwise leave the event saying
-            # SELECT. The COPY's data is written again on the way out.
-
-            try:
-                return await wrapped(*args, **kwargs)
-            finally:
-                wrapture.annotate(**data)
+            wrapture.annotate(**data_for(instance, query_of(args, kwargs), "COPY"))
+            return await wrapped(*args, **kwargs)
 
         return record()
 

{wrapture_instrumentation_postgresql-1.0.0.dev1 → wrapture_instrumentation_postgresql-1.0.0.dev2}/src/wrapture_instrumentation_postgresql.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wrapture-instrumentation-postgresql
-Version: 1.0.0.dev1
+Version: 1.0.0.dev2
 Summary: Instrumentation for the PostgreSQL client libraries (psycopg, psycopg2, asyncpg), applied through wrapture.
 Author-email: Graham Dumpleton <Graham.Dumpleton@gmail.com>
 License-Expression: BSD-2-Clause
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: wrapture>=1.0.0a20
+Requires-Dist: wrapture>=1.0.0a21
 Dynamic: license-file
 
 # wrapture-instrumentation-postgresql
@@ -109,7 +109,7 @@ $ python -m wrapture.tools instrumentation --verbose
 | ------ | ------------------ | ------- | -------- |
 | [`psycopg`](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/src/wrapture_instrumentation_postgresql/psycopg/README.md) | psycopg 3.1+ (3.x) | Every query as one `database` leaf, however it was issued (a cursor's `execute` or `executemany`, the connection's shortcut, a streamed query, a COPY, a server-side cursor's DECLARE), plus the connection being opened and each transaction boundary (`commit`, `rollback`, the connection's context manager, and a `transaction()` block's begin and end, savepoints included); sync and async classes alike, and connections from a pool. Each event carries the system, the operation, and the database, host and port it reached; a failing statement records the driver's exception. The SQL text is recorded only with the `statement` setting on, bound parameters never. | `statement` |
 | [`psycopg2`](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/src/wrapture_instrumentation_postgresql/psycopg2/README.md) | psycopg2 2.9+ (2.x), psycopg2-binary alike | Every query as one `database` leaf, however it was issued (`execute`, `executemany`, `callproc`, the extras' batch helpers, a named cursor's DECLARE), each COPY (`copy_from`, `copy_to`, `copy_expert`), the connection being opened and each transaction boundary (`commit`, `rollback`, the connection's context manager); through recording subclasses injected by psycopg2's own factory mechanism, so your `cursor_factory` and `connection_factory` classes keep working and are recorded too. Each event carries the system, the operation, and the database, host and port it reached; a failing statement records the driver's exception. The SQL text (the template with its placeholders) is recorded only with the `statement` setting on, bound parameters never. | `statement` |
-| [`asyncpg`](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/src/wrapture_instrumentation_postgresql/asyncpg/README.md) | asyncpg 0.29+ (0.x) | Every query as one `database` leaf recorded around its await, however it was issued (a connection's `execute`, `executemany`, `fetch`, `fetchrow`, `fetchval` or `fetchmany`, a prepared statement's own fetches, a server-side cursor's DECLARE and each FETCH), each COPY, the connection being opened, and each transaction boundary, which asyncpg issues through `execute`. Each event carries the system, the operation, and the database, host and port it reached; a failing statement records the driver's exception. The SQL text (with its `$n` placeholders) is recorded only with the `statement` setting on, query arguments never. A connection taken from a pool does not yet record its queries (a wrapture fix is pending). | `statement` |
+| [`asyncpg`](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/src/wrapture_instrumentation_postgresql/asyncpg/README.md) | asyncpg 0.29+ (0.x) | Every query as one `database` leaf recorded around its await, however it was issued (a connection's `execute`, `executemany`, `fetch`, `fetchrow`, `fetchval` or `fetchmany`, a prepared statement's own fetches, a server-side cursor's DECLARE and each FETCH), each COPY, the connection being opened, and each transaction boundary, which asyncpg issues through `execute`. Each event carries the system, the operation, and the database, host and port it reached; a failing statement records the driver's exception. The SQL text (with its `$n` placeholders) is recorded only with the `statement` setting on, query arguments never. A connection taken from a pool records its queries like any other. | `statement` |
 
 The entry point name is the config's `name`""; the linked per-target
 README is the full user documentation: what records, what the events
@@ -127,11 +127,6 @@ By design, and where it goes:
   records its queries like any other, but taking and returning it are
   not database operations and are not recorded.
 
-- A connection taken from an asyncpg pool does not yet record its
-  queries: the pool proxy calls the connection's methods through the
-  class, a calling convention wrapture's signature check does not
-  yet handle. The fix is on wrapture's side.
-
 - LISTEN/NOTIFY, large objects and two-phase commit are out of scope.
 
 ## Adding a target

wrapture_instrumentation_postgresql-1.0.0.dev2/src/wrapture_instrumentation_postgresql.egg-info/requires.txt

@@ -0,0 +1 @@
+wrapture>=1.0.0a21

{wrapture_instrumentation_postgresql-1.0.0.dev1 → wrapture_instrumentation_postgresql-1.0.0.dev2}/tests/asyncpg/test_recording.py

@@ -401,20 +401,13 @@ def test_a_pool_opens_its_connections_through_connect(
     contract(event, postgresql, "CONNECT")
 
 
-@pytest.mark.xfail(
-    strict=True,
-    reason=(
-        "asyncpg's PoolConnectionProxy calls Connection's methods through the"
-        " class, Connection.fetchval(connection, query), and wrapture's"
-        " signature check binds the arguments against the unbound function,"
-        " so the call is refused as missing its query; a wrapture fix is"
-        " needed (resolve the signature with the instance already bound"
-        " when wrapt hands over a partial)"
-    ),
-)
 def test_a_pooled_connection_records_its_queries(
     postgresql: Server, tape: Tape
 ) -> None:
+    # asyncpg's pool proxy calls the connection's methods through the
+    # class, Connection.fetchval(connection, query); wrapture (on
+    # wrapt 2.4.1) binds that the same as the instance call.
+
     async def workload() -> int:
         pool = await asyncpg.create_pool(postgresql.url, min_size=1, max_size=1)
         try:

wrapture_instrumentation_postgresql-1.0.0.dev1/src/wrapture_instrumentation_postgresql.egg-info/requires.txt

@@ -1 +0,0 @@
-wrapture>=1.0.0a20