wrapture-instrumentation-postgresql 1.0.0.dev1__py3-none-any.whl

wrapture_instrumentation_postgresql/psycopg2/factories.py

@@ -0,0 +1,402 @@
+"""The psycopg2 patches: the connect factory bound, and the
+connections it returns made instances of recording subclasses, their
+cursors likewise.
+
+psycopg2's connection and cursor are C types, so there is no
+attribute on them a binding could patch, and a proxy around them is
+not an option either: psycopg2's own C entry points type-check the
+objects handed back to them (`register_type`, and so `register_uuid`,
+`register_hstore`, `register_json` and `register_composite`, plus
+`quote_ident`, `Json(...).prepare()` and `lobject`), and a proxy
+fails those checks. What psycopg2 does support is subclassing: the
+`connection_factory=` argument to `connect()` and the `cursor_factory`
+of a connection or a `cursor()` call are how its own extras
+(`LoggingConnection`, `DictCursor`) work. The instrumentation uses
+that mechanism: the one seam is `psycopg2.connect`, bound to record
+the open and to substitute the requested connection factory with a
+recording subclass of it, and that subclass hands out cursors that
+are recording subclasses of whatever cursor class was asked for.
+
+The recording subclasses are made per base class and cached: a mixin
+of plain Python methods (`CursorMixin`, `ConnectionMixin`) placed
+ahead of the base in the bases, each override calling the base's
+method through super(), so the application's own factories
+(`RealDictConnection`, `DictCursor`, `LoggingConnection`) keep
+working and are simply recorded. The subclass takes the base's name
+and module, so reprs read as before; isinstance checks and the C
+type checks pass, since these are real subclasses. Those mixin
+methods are what wrapture binds, each labelled with the psycopg2 name
+it stands for (`psycopg2.extensions:cursor.execute`), the one thing
+its recorded path cannot say.
+
+Cursors are made recording in `ConnectionMixin.cursor`. A cursor class
+named explicitly, in the call or on the connection's `cursor_factory`,
+is substituted with its recording subclass before the base builds
+the cursor. When nothing names one and the base would fall back to
+psycopg2's own C cursor type, the recording subclass of that type is
+passed explicitly, since an instance of the C type itself cannot be
+reclassed afterwards. When a base class's own `cursor()` supplies a
+default (the extras' connection classes do), it runs first and the
+cursor it returns, an instance of a Python subclass, is reclassed to
+the recording subclass of its class on the way out, which Python
+permits for compatible heap types.
+
+The recorded set is the acquisition, the execute family and the
+transaction boundaries: `connect`; `execute`, `executemany` and
+`callproc`; `copy_from`, `copy_to` and `copy_expert`; `commit` and
+`rollback`; and the connection's commit-or-rollback context manager,
+whose exit records which of the two it performed (psycopg2's does
+not close the connection). Cursor creation and the fetch methods are
+not recorded, and a named cursor's FETCHes not either, the model
+every database target here follows. Every event carries the
+database contract keys and the server reached, from the connection's
+info; the SQL text as the application handed it over (psycopg2
+interpolates the parameters client-side below this seam, so the
+recorded text carries the placeholders) rides as `statement` only
+when the setting is on, and bound parameters are never recorded.
+
+Removing the instrumentation removes the bindings and restores
+`connect`: connections already made keep their recording classes,
+whose methods then delegate without recording.
+"""
+
+from __future__ import annotations
+
+from types import TracebackType
+from typing import Any, cast
+
+import wrapture
+
+from ..common import SYSTEM, captured, query_data, server_of
+
+_connections: dict[type, type] = {}
+_cursors: dict[type, type] = {}
+
+
+class CursorMixin:
+    """The recording overrides placed ahead of a psycopg2 cursor class:
+    each calls the base's method through super(), and each is bound
+    by wrapture below."""
+
+    def execute(self, query: Any, vars: Any = None) -> Any:
+        return cast(Any, super()).execute(query, vars)
+
+    def executemany(self, query: Any, vars_list: Any) -> Any:
+        return cast(Any, super()).executemany(query, vars_list)
+
+    def callproc(self, procname: Any, parameters: Any = None) -> Any:
+        return cast(Any, super()).callproc(procname, parameters)
+
+    def copy_from(
+        self,
+        file: Any,
+        table: Any,
+        sep: str = "\t",
+        null: str = "\\N",
+        size: int = 8192,
+        columns: Any = None,
+    ) -> Any:
+        return cast(Any, super()).copy_from(
+            file, table, sep=sep, null=null, size=size, columns=columns
+        )
+
+    def copy_to(
+        self,
+        file: Any,
+        table: Any,
+        sep: str = "\t",
+        null: str = "\\N",
+        columns: Any = None,
+    ) -> Any:
+        return cast(Any, super()).copy_to(
+            file, table, sep=sep, null=null, columns=columns
+        )
+
+    def copy_expert(self, sql: Any, file: Any, size: int = 8192) -> Any:
+        return cast(Any, super()).copy_expert(sql, file, size=size)
+
+
+class ConnectionMixin:
+    """The recording overrides placed ahead of a psycopg2 connection
+    class: cursors come back as recording subclasses, and the
+    transaction boundaries call through to the base and are bound by
+    wrapture below."""
+
+    def cursor(self, *args: Any, **kwargs: Any) -> Any:
+        # A cursor class named in the call (by keyword or in the
+        # second positional slot) is substituted with its recording
+        # subclass before the base builds the cursor.
+
+        if "cursor_factory" in kwargs:
+            factory = kwargs["cursor_factory"]
+        elif len(args) > 1:
+            factory = args[1]
+        else:
+            factory = None
+
+        if factory is not None:
+            recording = recording_cursor(factory)
+            if "cursor_factory" in kwargs:
+                kwargs["cursor_factory"] = recording
+            else:
+                args = (args[0], recording, *args[2:])
+
+        # With none named and nothing set on the connection, a base
+        # that falls straight through to the C method would build an
+        # instance of the C cursor type, which cannot be reclassed
+        # afterwards, so its recording subclass is named explicitly.
+
+        elif getattr(self, "cursor_factory", None) is None and _falls_through(
+            type(self)
+        ):
+            kwargs["cursor_factory"] = recording_cursor(_c_cursor_type())
+
+        cursor = cast(Any, super()).cursor(*args, **kwargs)
+
+        # A base's own cursor() may have supplied its default cursor
+        # class instead; its instance is reclassed on the way out.
+
+        if not isinstance(cursor, CursorMixin):
+            try:
+                cursor.__class__ = recording_cursor(type(cursor))
+            except TypeError:
+                pass
+
+        return cursor
+
+    def commit(self) -> Any:
+        return cast(Any, super()).commit()
+
+    def rollback(self) -> Any:
+        return cast(Any, super()).rollback()
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> Any:
+        return cast(Any, super()).__exit__(exc_type, exc_value, traceback)
+
+
+def _c_cursor_type() -> type:
+    import psycopg2.extensions
+
+    return cast(type, psycopg2.extensions.cursor)
+
+
+def _falls_through(cls: type) -> bool:
+    """Whether cursor() on the given recording connection class, past
+    the mixin, is psycopg2's own C method rather than an override of
+    a base class supplying a cursor default of its own."""
+
+    import psycopg2.extensions
+
+    for base in cls.__mro__:
+        if base is ConnectionMixin:
+            continue
+        if "cursor" in vars(base):
+            return base is psycopg2.extensions.connection
+
+    return True
+
+
+def _recording(cache: dict[type, type], mixin: type, base: type) -> type:
+    if isinstance(base, type) and issubclass(base, mixin):
+        return base
+
+    try:
+        return cache[base]
+    except KeyError:
+        pass
+
+    made = type(
+        base.__name__,
+        (mixin, base),
+        {"__module__": base.__module__, "__qualname__": base.__qualname__},
+    )
+    cache[base] = made
+
+    return made
+
+
+def recording_cursor(base: type) -> type:
+    """The recording subclass of a psycopg2 cursor class, made once
+    per class; a class already recording is returned as is."""
+
+    return _recording(_cursors, CursorMixin, base)
+
+
+def recording_connection(base: type) -> type:
+    """The recording subclass of a psycopg2 connection class, made
+    once per class; a class already recording is returned as is."""
+
+    return _recording(_connections, ConnectionMixin, base)
+
+
+def instrument(module: Any, instrumentation: wrapture.Instrumentation) -> None:
+    """Bind the connect factory and the mixins' methods; register
+    their removal as this trigger's cleanup."""
+
+    settings = instrumentation.settings
+    record_statement = bool(settings["statement"])
+
+    def data_for(
+        cursor: Any, query: Any, operation: str | None = None
+    ) -> dict[str, Any]:
+        return query_data(
+            query, cursor, cursor.connection.info, record_statement, operation
+        )
+
+    def opens(
+        wrapped: Any, instance: Any, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> Any:
+        wrapture.annotate(system=SYSTEM, operation="CONNECT")
+
+        # The requested connection class (keyword, or the second
+        # positional slot) is replaced with its recording subclass.
+
+        if "connection_factory" in kwargs:
+            factory = kwargs["connection_factory"]
+        elif len(args) > 1:
+            factory = args[1]
+        else:
+            factory = None
+
+        recording = recording_connection(factory or module.extensions.connection)
+        if "connection_factory" in kwargs or len(args) <= 1:
+            kwargs["connection_factory"] = recording
+        else:
+            args = (args[0], recording, *args[2:])
+
+        connection = wrapped(*args, **kwargs)
+        wrapture.annotate(**server_of(connection.info))
+
+        return connection
+
+    def queries(
+        wrapped: Any, instance: Any, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> Any:
+        query = args[0] if args else kwargs.get("query")
+        wrapture.annotate(**data_for(instance, query))
+
+        return wrapped(*args, **kwargs)
+
+    def calls(
+        wrapped: Any, instance: Any, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> Any:
+        procname = args[0] if args else kwargs.get("procname")
+        data = data_for(instance, None, "CALL")
+        if isinstance(procname, str):
+            data["procedure"] = procname
+        wrapture.annotate(**data)
+
+        return wrapped(*args, **kwargs)
+
+    def copies_table(
+        wrapped: Any, instance: Any, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> Any:
+        table = args[1] if len(args) > 1 else kwargs.get("table")
+        data = data_for(instance, None, "COPY")
+        if isinstance(table, str):
+            data["collection"] = table
+        wrapture.annotate(**data)
+
+        return wrapped(*args, **kwargs)
+
+    def copies_statement(
+        wrapped: Any, instance: Any, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> Any:
+        sql = args[0] if args else kwargs.get("sql")
+        wrapture.annotate(**data_for(instance, sql, "COPY"))
+
+        return wrapped(*args, **kwargs)
+
+    def performs(operation: str) -> Any:
+        def record(
+            wrapped: Any,
+            instance: Any,
+            args: tuple[Any, ...],
+            kwargs: dict[str, Any],
+        ) -> Any:
+            wrapture.annotate(
+                system=SYSTEM, operation=operation, **server_of(instance.info)
+            )
+
+            return wrapped(*args, **kwargs)
+
+        return record
+
+    def leaves(
+        wrapped: Any, instance: Any, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> Any:
+        # The exit commits unless an exception is on its way through.
+
+        exc_type = args[0] if args else kwargs.get("exc_type")
+        operation = "COMMIT" if exc_type is None else "ROLLBACK"
+        wrapture.annotate(
+            system=SYSTEM, operation=operation, **server_of(instance.info)
+        )
+
+        return wrapped(*args, **kwargs)
+
+    def database_binding(
+        owner: Any, name: str, label: str | None = None, capture_args: Any = captured
+    ) -> wrapture.Binding:
+        return wrapture.binding(
+            owner,
+            name,
+            label=label,
+            category="database",
+            leaf=True,
+            capture_args=capture_args,
+            capture_result=captured,
+        )
+
+    named: dict[str, wrapture.Binding] = {}
+
+    # The factory: the module attribute's path says psycopg2:connect
+    # already, so it takes no label, and none of its arguments are
+    # captured (the dsn carries the password).
+
+    connect = database_binding(module, "connect", capture_args="none")
+    connect.on_call.decorates(opens)
+    named["connect"] = connect
+
+    # The cursor methods, labelled with the psycopg2 names they stand
+    # for.
+
+    for method, decorator in (
+        ("execute", queries),
+        ("executemany", queries),
+        ("callproc", calls),
+        ("copy_from", copies_table),
+        ("copy_to", copies_table),
+        ("copy_expert", copies_statement),
+    ):
+        bound = database_binding(
+            CursorMixin, method, label=f"psycopg2.extensions:cursor.{method}"
+        )
+        bound.on_call.decorates(decorator)
+        named[f"cursor_{method}"] = bound
+
+    # The transaction boundaries: the explicit calls, and the context
+    # manager exit that performs one of them.
+
+    for method, operation in (("commit", "COMMIT"), ("rollback", "ROLLBACK")):
+        bound = database_binding(
+            ConnectionMixin, method, label=f"psycopg2.extensions:connection.{method}"
+        )
+        bound.on_call.decorates(performs(operation))
+        named[f"connection_{method}"] = bound
+
+    closes = database_binding(
+        ConnectionMixin, "__exit__", label="psycopg2.extensions:connection.__exit__"
+    )
+    closes.on_call.decorates(leaves)
+    named["connection_exit"] = closes
+
+    group = wrapture.bindings(**named)
+    group.apply()
+
+    instrumentation.on_cleanup(group.remove)

wrapture_instrumentation_postgresql-1.0.0.dev1.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: wrapture-instrumentation-postgresql
+Version: 1.0.0.dev1
+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
+Project-URL: Homepage, https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql
+Project-URL: Documentation, https://wrapture.readthedocs.io
+Project-URL: Bug Tracker, https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/issues/
+Keywords: wrapture,instrumentation,postgresql,psycopg,psycopg2,asyncpg,tracing
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: wrapture>=1.0.0a20
+Dynamic: license-file
+
+# wrapture-instrumentation-postgresql
+
+Instrumentation for the PostgreSQL client libraries, applied through
+[wrapture](https://github.com/GrahamDumpleton/wrapture).
+
+wrapture attaches bindings to arbitrary Python call sites without
+modifying the code being observed, and its config layer can switch on
+packaged instrumentation for a third-party package by name. This is
+the PostgreSQL package in that collection: one `wrapture.Instrumentation`
+class per client library, so tracing every query, connection and
+transaction your application sends to PostgreSQL is one config entry
+and no code.
+
+> **Status: alpha, ahead of 1.0.0.** Developed against wrapture's
+> alpha series, with pre-releases published to
+> [PyPI](https://pypi.org/project/wrapture-instrumentation-postgresql/),
+> and until 1.0.0 is final a plain `pip install
+> wrapture-instrumentation-postgresql` picks up the latest pre-release
+> automatically, so there is no need to pin a specific version.
+
+## Why a separate package
+
+The core
+[wrapture-instrumentation](https://github.com/GrahamDumpleton/wrapture-instrumentation)
+package deliberately covers only the standard library and third-party
+packages that can be exercised in-process, with no separate backend
+product or service needed to test against. A PostgreSQL driver is
+exactly the kind of target the separate-package rule was drawn for:
+its tests need a real server, so this package's suite runs one in a
+docker container, and it carries the drivers as test dependencies
+(some of them compiled wheels) and its own release cadence, so the
+core package's test matrix stays light. One package covers every
+client library for the one backend: psycopg, psycopg2 and asyncpg.
+
+## Installation
+
+```console
+$ pip install wrapture-instrumentation-postgresql
+```
+
+Installing it brings wrapture and nothing else. No driver is a
+dependency: each instrumentation is inert until its driver is present,
+and wrapture checks the installed version against the range the
+instrumentation supports at apply time.
+
+## Using it
+
+An `[[instrument]]` entry in `wrapture.toml` names the target:
+
+```toml
+[[instrument]]
+name = "psycopg"
+
+[[sink]]
+type = "printer"
+```
+
+and the runner applies it before the application starts, so the patch
+is in place before the driver is imported:
+
+```console
+$ python -m wrapture -m myapp
+```
+
+The same config works through
+[autowrapt](https://github.com/GrahamDumpleton/autowrapt) injection
+(`AUTOWRAPT_BOOTSTRAP=wrapture python myapp.py`); through
+[manual setup](https://wrapture.readthedocs.io/en/latest/manual-setup.html),
+a few lines in the application's own startup where wrapping the launch
+from outside is awkward; and, in a test, through
+`wrapture.instrumentation("psycopg")` scoping the instrumentation to
+a block. The
+[ad-hoc tracing guide](https://wrapture.readthedocs.io/en/latest/ad-hoc-tracing.html)
+covers the config file itself.
+
+To see what is installed, what it supports in the current
+environment, and what settings it takes:
+
+```console
+$ python -m wrapture.tools instrumentation --verbose
+```
+
+## Provided instrumentation
+
+| Target | Supported versions | Records | Settings |
+| ------ | ------------------ | ------- | -------- |
+| [`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` |
+
+The entry point name is the config's `name`""; the linked per-target
+README is the full user documentation: what records, what the events
+carry, the setting, and what is deliberately not traced.
+
+## What is not traced
+
+By design, and where it goes:
+
+- Fetching rows: a query event closes when its execute returns, so
+  time spent iterating rows afterwards is the application's, and a
+  server-side cursor's FETCHes are not recorded (its DECLARE is).
+
+- Pool checkouts (`psycopg_pool`): a connection taken from a pool
+  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
+
+Each client library is its own subpackage and entry point here. The
+subpackage's `__init__.py` holds one `wrapture.Instrumentation`
+subclass and imports only wrapture (and the package's own `common.py`,
+which imports only wrapture too); everything that touches the driver
+lives in sibling modules imported inside the hook. The class is
+registered in `pyproject.toml` under
+`[project.entry-points."wrapture.instrumentation"]`, and gets its own
+test suite under `tests/<target>/` and a `README.md` linked from the
+table above. The
+[instrumentation packages](https://wrapture.readthedocs.io/en/latest/instrumentation-packages.html)
+page of the wrapture documentation is the full contract; TESTING.md
+here covers the tests and the server they run against.
+
+## License
+
+BSD 2-Clause. See
+[LICENSE](https://github.com/GrahamDumpleton/wrapture-instrumentation-postgresql/blob/develop/LICENSE).

wrapture_instrumentation_postgresql-1.0.0.dev1.dist-info/RECORD

@@ -0,0 +1,22 @@
+wrapture_instrumentation_postgresql/__init__.py,sha256=WA0NLvebvLdxRWlvGnabFloQHU1Q8b4b4VWjpV3aZSo,755
+wrapture_instrumentation_postgresql/common.py,sha256=bkRjg8p4nb1HMhzDZN55J9Dh-kGZ6Wr0gUt1I9nEdNU,5457
+wrapture_instrumentation_postgresql/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wrapture_instrumentation_postgresql/asyncpg/README.md,sha256=PPxCwe1LLrvHpEg7X516O5sfL2MqR9hbAcFPBrOG-z0,6014
+wrapture_instrumentation_postgresql/asyncpg/__init__.py,sha256=yb_axU7Ii-2LyqOjzXKgB7Z3lV5jcXsrDWyNOXJyTwY,2689
+wrapture_instrumentation_postgresql/asyncpg/connection.py,sha256=HH5vinUeXs678wpV-puoQ0RwIbyQ4nJfAMTnKYlSmy8,7538
+wrapture_instrumentation_postgresql/asyncpg/cursor.py,sha256=2_X9YIxRSDDhTLAKAaJULAAlQobwGr6b4asxf_IB5Yk,3169
+wrapture_instrumentation_postgresql/asyncpg/prepared.py,sha256=mW71-YRdvnyEkMO444ATjsnioa-IAKH7kwCaQVp5PKk,2485
+wrapture_instrumentation_postgresql/psycopg/README.md,sha256=WzCd-v6b2wrfkaOZ2oNJBpPtPgHiRWaPe359o7wPTos,6642
+wrapture_instrumentation_postgresql/psycopg/__init__.py,sha256=36aNivArazNIE8Mj_yzYFY_uYnHjlcfWAwc4y4oo2Y4,2019
+wrapture_instrumentation_postgresql/psycopg/connection.py,sha256=tcuE2v6FVaEO9Or2ut0980yhKphN8sUp5N06m49Qq4A,5696
+wrapture_instrumentation_postgresql/psycopg/cursor.py,sha256=qhK4i1Qf8Ho36oyCBQ714MGy0CBJNiY7MUqNDuwmEwU,9063
+wrapture_instrumentation_postgresql/psycopg/transaction.py,sha256=27FP_Iin2jZknZ8IsLJquuK6mkSmz9llKOtCWVsmxLs,4427
+wrapture_instrumentation_postgresql/psycopg2/README.md,sha256=AWU5p9nCbx7wEGQILk4cBauo9y_KfqlkRxU_TBsYS2A,5897
+wrapture_instrumentation_postgresql/psycopg2/__init__.py,sha256=CP_9F74TjeDGeGU3S0DPyVvNa02HuYeaQqd0EsN0pOg,1649
+wrapture_instrumentation_postgresql/psycopg2/factories.py,sha256=cBcc5W1ywljUqIQSu8_7YV_M4t3Q4ktCYk-kkonr5Ds,14314
+wrapture_instrumentation_postgresql-1.0.0.dev1.dist-info/licenses/LICENSE,sha256=RPMyRnXwgrw9co5o6wY9G3DKlb-oBZ44tpiRnuYeec8,1299
+wrapture_instrumentation_postgresql-1.0.0.dev1.dist-info/METADATA,sha256=P76R8MC0fqKxN71T71AjYtRofVZyoxX3ay7_rIrCdZg,8933
+wrapture_instrumentation_postgresql-1.0.0.dev1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+wrapture_instrumentation_postgresql-1.0.0.dev1.dist-info/entry_points.txt,sha256=pPB1skIzk-3RIv8jXObnlfM0rW7uiKTnCgyQ6hJ4lA0,261
+wrapture_instrumentation_postgresql-1.0.0.dev1.dist-info/top_level.txt,sha256=xAb-vQUXGc51uRzpvxOF3M-gjE9VqNlTzdlLOFkDPHA,36
+wrapture_instrumentation_postgresql-1.0.0.dev1.dist-info/RECORD,,

wrapture_instrumentation_postgresql-1.0.0.dev1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

wrapture_instrumentation_postgresql-1.0.0.dev1.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[wrapture.instrumentation]
+asyncpg = wrapture_instrumentation_postgresql.asyncpg:AsyncpgInstrumentation
+psycopg = wrapture_instrumentation_postgresql.psycopg:PsycopgInstrumentation
+psycopg2 = wrapture_instrumentation_postgresql.psycopg2:Psycopg2Instrumentation

wrapture_instrumentation_postgresql-1.0.0.dev1.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2026, Graham Dumpleton
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

wrapture_instrumentation_postgresql-1.0.0.dev1.dist-info/top_level.txt

@@ -0,0 +1 @@
+wrapture_instrumentation_postgresql