hexkit 8.4.1__tar.gz → 8.5.0__tar.gz

{hexkit-8.4.1/src/hexkit.egg-info → hexkit-8.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexkit
-Version: 8.4.1
+Version: 8.5.0
 Summary: A Toolkit for Building Microservices using the Hexagonal Architecture
 Author-email: "German Human Genome Phenome Archive (GHGA)" <contact@ghga.de>
 License: Apache 2.0
@@ -89,75 +89,83 @@ Requires-Dist: hexkit[test]; extra == "all"
 Requires-Dist: hexkit[opentelemetry]; extra == "all"
 Dynamic: license-file
 
-![tests](https://github.com/ghga-de/hexkit/actions/workflows/tests.yaml/badge.svg)
 [![PyPI version shields.io](https://img.shields.io/pypi/v/hexkit.svg)](https://pypi.python.org/pypi/hexkit/)
 [![PyPI pyversions](https://img.shields.io/pypi/pyversions/hexkit.svg)](https://pypi.python.org/pypi/hexkit/)
+![tests](https://github.com/ghga-de/hexkit/actions/workflows/tests.yaml/badge.svg)
 [![Coverage Status](https://coveralls.io/repos/github/ghga-de/hexkit/badge.svg?branch=main)](https://coveralls.io/github/ghga-de/hexkit?branch=main)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
 
 # hexkit
 
-A chassis library for building domain-focused, infrastructure-agnostic, and event-driven
-microservices in Python.
+*A chassis library for building domain-focused, infrastructure-agnostic,
+and event-driven microservices in Python*
+
+Read the short summary below, or jump straight to our full
+📖 **[User Guide](https://ghga-de.github.io/hexkit/user-guide/)** to learn the abstract
+concepts and patterns as well as the concrete infrastructure integrations and testing
+tools that hexkit provides for building better microservices.
+
+<!--
+NOTE: This README doubles as the landing page of the documentation site built with
+great-docs. Therefore, all links must be absolute URLs — repo-relative links like
+./examples or ./src would resolve correctly on GitHub but break on the site.
+-->
 
 ## In a Nutshell
 
-This project implements the Triple Hexagonal Architecture pattern which is an
-optimization of the ordinary
+hexkit implements the *Triple Hexagonal Architecture* pattern, an optimization of the
+ordinary
 [Hexagonal Architecture](https://alistair.cockburn.us/hexagonal-architecture/) for
-use with microservices.
-In brief, adapters (as per the hexagonal architecture) are divided into two parts.
-One part called *translator* is specific to one individual microservice and its
-domain-oriented ports.
-The other part called *provider* is service-agnostic but specific to one
-technology of the surrounding infrastructure.
-Both parts interact through a high-level interface called *protocol* (not to be
-confused with Python's typing.Protocol) which is neither
-specific to the technology nor to the microservice.
-For more details on the Triple Hexagonal Architecture, refer to the concept paper that
-can be found
-[here](https://ghga-de.github.io/developer-cookbook/articles/2_triple_hexagonal/).
-
-As a chassis lib, hexkit tries to reduce the redundancy and boilerplate across
-microservices. It does so by providing ready-to-use triple-hexagonal building blocks
-that are service-independent - hence protocols and providers. The only task that remains
-for an individual service is to implement service-specific translators between the
-service's ports and the general-purpose protocols (in addition to implementing the
-domain functionality of the service, of course).
-
-Hexkit is designed as a general-purpose library. However, it currently contains only
-a limited collection of protocol-provider pairs that are of immediate interest to the
-authors. We like to add support for more protocols and technologies over time.
+use with microservices: adapters (as per the hexagonal architecture) are divided into
+two parts. One part called *translator* is specific to one individual microservice
+and its domain-oriented ports. The other part called *provider* is service-agnostic
+but specific to one technology of the surrounding infrastructure. Both parts interact
+through a high-level interface called *protocol* (not to be confused with Python's
+typing.Protocol) which is neither specific to the technology nor to the microservice.
+
+As a chassis lib, hexkit reduces redundancy and boilerplate across microservices by
+providing the service-independent building blocks — protocols and providers — ready
+to use. The only task that remains for an individual service is to implement
+service-specific translators between the service's ports and the general-purpose
+protocols (in addition to implementing the domain functionality of the service, of
+course). For an in-depth introduction to the pattern, please read the
+[Architectural Concepts](https://ghga-de.github.io/hexkit/user-guide/arch_concepts/)
+chapter of the User Guide.
 
 The following protocols and providers are currently available:
 
-| Protocol | Providers |
-|---|---|
-| Event Publishing | Apache Kafka |
-| Event Subscription | Apache Kafka |
-| Object Storage | S3(-compatible) |
-| Data Access Object | MongoDB |
-
-Hexkit does not force you to go all-in on the idea of Triple Hexagonal Architecture.
-You can use it just for the technologies where you see benefits and use another approach
-for the rest. For example, you could use hexkit for simplifying the exchange of events
-between microservices but use a classical web framework such as FastAPI for designing
-REST API and an ORM like SQLAlchemy for interacting with databases.
-
-Feel free to develop hexagonal components yourself, whether or not you use the base
-classes of hexkit. Not every protocol or provider has to be general-purpose, however,
-if they are, please consider contributing them to hexkit.
-
-## Getting started
-
-Please have a look at the example application described in
-[./examples/stream_calc](./examples/stream_calc).
-
-We put a lot of effort into making the code self-documenting, so please do not be afraid
-of jumping directly into it. You can find the protocols being defined at
-[./src/hexkit/protocols](./src/hexkit/protocols) and the providers being implemented at
-[./src/hexkit/providers](./src/hexkit/providers).
-
-A more elaborate documentation and tutorial is on the way.
+| Protocol           | Providers                              |
+| ------------------ | -------------------------------------- |
+| Event Publishing   | Apache Kafka, MongoDB + Kafka (outbox) |
+| Event Subscription | Apache Kafka                           |
+| Data Access Object | MongoDB                                |
+| Object Storage     | S3(-compatible)                        |
+| Key-Value Store    | MongoDB, Redis, S3, HashiCorp Vault    |
+
+In-memory implementations and per-backend test utilities are also included to
+support testing without real infrastructure.
+
+You are not forced to go all-in on the idea of Triple Hexagonal Architecture.
+You can use it just for the technologies where you see benefits and use another
+approach for the rest. For example, you could use hexkit for simplifying the exchange
+of events between microservices but use a classical web framework such as FastAPI for
+designing REST APIs and an ORM like SQLAlchemy for interacting with databases.
+
+## Getting Started
+
+The 📖 [User Guide](https://ghga-de.github.io/hexkit/user-guide/) covers all
+protocols, providers, testing utilities, and observability tools with example code,
+and the [API Reference](https://ghga-de.github.io/hexkit/reference/) documents all
+public classes and functions.
+
+For a complete example service built with hexkit, have a look at the
+[stream_calc](https://github.com/ghga-de/hexkit/tree/main/examples/stream_calc)
+example application. We also put a lot of effort into making the code
+self-documenting: you can find the protocols being defined at
+[src/hexkit/protocols](https://github.com/ghga-de/hexkit/tree/main/src/hexkit/protocols)
+and the providers being implemented at
+[src/hexkit/providers](https://github.com/ghga-de/hexkit/tree/main/src/hexkit/providers).
 
 ## Installation
 
@@ -173,51 +181,29 @@ pip install hexkit
 The following extras are available:
 
 - `akafka`: when using the Apache Kafka-based event publishing or subscription
-- `s3`: when interacting with S3-compatible Object Storages
-- `mongodb`: when using mongodb as backend for the DAO protocol
-- `test-akafka`: testing utils for Apache Kafka
-- `test-s3`: testing utils for S3-compatible Object Storages
-- `test-mongodb`: testing utils for MongoDB
+- `mongodb`: when using MongoDB as backend for the DAO protocol or key-value stores
+- `s3`: when interacting with S3-compatible object storages or key-value stores
+- `redis`: when using Redis-based key-value stores
+- `vault`: when using HashiCorp Vault-based key-value stores
+- `opentelemetry`: observability instrumentation (also available per backend, e.g.
+  `opentelemetry-akafka`, `opentelemetry-mongodb`, `opentelemetry-fastapi`)
+- `test-akafka`, `test-mongodb`, `test-s3`, `test-redis`, `test-vault`: testing
+  utils for the respective backend (`test` is a union of all of them)
 - `all`: a union of all the above
 
-## Development
-
-For setting up the development environment, we rely on the
-[devcontainer feature](https://code.visualstudio.com/docs/remote/containers) of vscode.
-
-To use it, you need Docker and VS Code with the "Remote - Containers" extension
-(`ms-vscode-remote.remote-containers`) installed.
-Then, you just have to open this repo in vscode and run the command
-`Remote-Containers: Reopen in Container` from the vscode "Command Palette".
-
-This will give you a full-fledged, pre-configured development environment including:
-
-- infrastructural dependencies of the service (databases, etc.)
-- all relevant vscode extensions pre-installed
-- pre-configured linting and auto-formatting
-- a pre-configured debugger
-- automatic license-header insertion
+## Contributing
 
-Additionally, the following convenience command is available inside the devcontainer
-(type it in the integrated terminal of VS Code):
+Contributions are welcome! Please see the
+[contribution guide](https://github.com/ghga-de/hexkit/blob/main/CONTRIBUTING.md)
+for how to set up the development environment and build the documentation locally.
 
-- `dev_install` - install the lib with all development dependencies and pre-commit hooks
-(please run that if you are starting the devcontainer for the first time
-or if added any python dependencies to the [`./pyproject.toml`](./pyproject.toml))
+## Credits
 
-If you prefer not to use vscode, you could get a similar setup (without the editor
-specific features) by running the following commands:
-
-``` bash
-# Execute in the repo's root dir:
-cd ./.devcontainer
-
-# build and run the environment with docker-compose
-docker build -t hexkit .
-docker run -it hexkit /bin/bash
-
-```
+The hexkit library is developed and maintained by the developer team of GHGA. We would especially
+like to thank its original author, Kersten Breuer, who came up with the idea for the
+library and designed and coded its first versions.
 
 ## License
 
-This repository is free to use and modify according to the [Apache 2.0 License](./LICENSE).
+This repository is free to use and modify according to the
+[Apache 2.0 License](https://github.com/ghga-de/hexkit/blob/main/LICENSE).

hexkit-8.5.0/README.md

@@ -0,0 +1,118 @@
+[![PyPI version shields.io](https://img.shields.io/pypi/v/hexkit.svg)](https://pypi.python.org/pypi/hexkit/)
+[![PyPI pyversions](https://img.shields.io/pypi/pyversions/hexkit.svg)](https://pypi.python.org/pypi/hexkit/)
+![tests](https://github.com/ghga-de/hexkit/actions/workflows/tests.yaml/badge.svg)
+[![Coverage Status](https://coveralls.io/repos/github/ghga-de/hexkit/badge.svg?branch=main)](https://coveralls.io/github/ghga-de/hexkit?branch=main)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+
+# hexkit
+
+*A chassis library for building domain-focused, infrastructure-agnostic,
+and event-driven microservices in Python*
+
+Read the short summary below, or jump straight to our full
+📖 **[User Guide](https://ghga-de.github.io/hexkit/user-guide/)** to learn the abstract
+concepts and patterns as well as the concrete infrastructure integrations and testing
+tools that hexkit provides for building better microservices.
+
+<!--
+NOTE: This README doubles as the landing page of the documentation site built with
+great-docs. Therefore, all links must be absolute URLs — repo-relative links like
+./examples or ./src would resolve correctly on GitHub but break on the site.
+-->
+
+## In a Nutshell
+
+hexkit implements the *Triple Hexagonal Architecture* pattern, an optimization of the
+ordinary
+[Hexagonal Architecture](https://alistair.cockburn.us/hexagonal-architecture/) for
+use with microservices: adapters (as per the hexagonal architecture) are divided into
+two parts. One part called *translator* is specific to one individual microservice
+and its domain-oriented ports. The other part called *provider* is service-agnostic
+but specific to one technology of the surrounding infrastructure. Both parts interact
+through a high-level interface called *protocol* (not to be confused with Python's
+typing.Protocol) which is neither specific to the technology nor to the microservice.
+
+As a chassis lib, hexkit reduces redundancy and boilerplate across microservices by
+providing the service-independent building blocks — protocols and providers — ready
+to use. The only task that remains for an individual service is to implement
+service-specific translators between the service's ports and the general-purpose
+protocols (in addition to implementing the domain functionality of the service, of
+course). For an in-depth introduction to the pattern, please read the
+[Architectural Concepts](https://ghga-de.github.io/hexkit/user-guide/arch_concepts/)
+chapter of the User Guide.
+
+The following protocols and providers are currently available:
+
+| Protocol           | Providers                              |
+| ------------------ | -------------------------------------- |
+| Event Publishing   | Apache Kafka, MongoDB + Kafka (outbox) |
+| Event Subscription | Apache Kafka                           |
+| Data Access Object | MongoDB                                |
+| Object Storage     | S3(-compatible)                        |
+| Key-Value Store    | MongoDB, Redis, S3, HashiCorp Vault    |
+
+In-memory implementations and per-backend test utilities are also included to
+support testing without real infrastructure.
+
+You are not forced to go all-in on the idea of Triple Hexagonal Architecture.
+You can use it just for the technologies where you see benefits and use another
+approach for the rest. For example, you could use hexkit for simplifying the exchange
+of events between microservices but use a classical web framework such as FastAPI for
+designing REST APIs and an ORM like SQLAlchemy for interacting with databases.
+
+## Getting Started
+
+The 📖 [User Guide](https://ghga-de.github.io/hexkit/user-guide/) covers all
+protocols, providers, testing utilities, and observability tools with example code,
+and the [API Reference](https://ghga-de.github.io/hexkit/reference/) documents all
+public classes and functions.
+
+For a complete example service built with hexkit, have a look at the
+[stream_calc](https://github.com/ghga-de/hexkit/tree/main/examples/stream_calc)
+example application. We also put a lot of effort into making the code
+self-documenting: you can find the protocols being defined at
+[src/hexkit/protocols](https://github.com/ghga-de/hexkit/tree/main/src/hexkit/protocols)
+and the providers being implemented at
+[src/hexkit/providers](https://github.com/ghga-de/hexkit/tree/main/src/hexkit/providers).
+
+## Installation
+
+This package is available at PyPI:
+<https://pypi.org/project/hexkit>
+
+You can install it from there using:
+
+```sh
+pip install hexkit
+```
+
+The following extras are available:
+
+- `akafka`: when using the Apache Kafka-based event publishing or subscription
+- `mongodb`: when using MongoDB as backend for the DAO protocol or key-value stores
+- `s3`: when interacting with S3-compatible object storages or key-value stores
+- `redis`: when using Redis-based key-value stores
+- `vault`: when using HashiCorp Vault-based key-value stores
+- `opentelemetry`: observability instrumentation (also available per backend, e.g.
+  `opentelemetry-akafka`, `opentelemetry-mongodb`, `opentelemetry-fastapi`)
+- `test-akafka`, `test-mongodb`, `test-s3`, `test-redis`, `test-vault`: testing
+  utils for the respective backend (`test` is a union of all of them)
+- `all`: a union of all the above
+
+## Contributing
+
+Contributions are welcome! Please see the
+[contribution guide](https://github.com/ghga-de/hexkit/blob/main/CONTRIBUTING.md)
+for how to set up the development environment and build the documentation locally.
+
+## Credits
+
+The hexkit library is developed and maintained by the developer team of GHGA. We would especially
+like to thank its original author, Kersten Breuer, who came up with the idea for the
+library and designed and coded its first versions.
+
+## License
+
+This repository is free to use and modify according to the
+[Apache 2.0 License](https://github.com/ghga-de/hexkit/blob/main/LICENSE).

{hexkit-8.4.1 → hexkit-8.5.0}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
     "Intended Audience :: Developers",
 ]
 name = "hexkit"
-version = "8.4.1"
+version = "8.5.0"
 description = "A Toolkit for Building Microservices using the Hexagonal Architecture"
 dependencies = [
     "opentelemetry-api >=1.39, <2",
@@ -157,6 +157,9 @@ ignore = [
     "E111",
     "E114",
     "E116",
+    "E117",
+    "E501",
+    "W191",
     "PLW",
     "RUF001",
     "RUF010",
@@ -185,6 +188,13 @@ select = [
     "RUF",
     "SIM",
     "D",
+    "E",
+    "W",
+    "ASYNC",
+    "LOG",
+    "PERF",
+    "RET",
+    "C4",
 ]
 
 [tool.ruff.lint.mccabe]
@@ -196,6 +206,7 @@ max-complexity = 10
     "S",
     "SIM",
     "D",
+    "E402",
 ]
 "tests/*" = [
     "S",
@@ -256,19 +267,14 @@ legacy_tox_ini = """
 
     [testenv:docs]
     basepython = python3.13
-    allowlist_externals =
-        mv
-        rm
     deps =
         --no-deps -r ./lock/requirements-dev.txt
+    commands_pre =
+        # great-docs (Python >= 3.11 only) is kept out of the shared dev lock so it
+        # does not break the py310 test env; install it here where docs are built.
+        pip install great-docs==0.14.1
     commands =
-        rm -rf site/api
-        pdoc -d google -o docs/api hexkit
-        mv docs/api/index.html docs/api/index.md
-        mkdocs build
-        mv docs/api/index.md docs/api/index.html
-        rm -rf site/api
-        mv docs/api site/api
+        great-docs build
 
     [testenv]
     pass_env =

{hexkit-8.4.1 → hexkit-8.5.0}/src/hexkit/log.py

@@ -105,7 +105,7 @@ class JsonFormatter(Formatter):
         """
         # Create a log record dictionary
         log_record = record.__dict__
-        output: dict[str, Any] = dict()
+        output: dict[str, Any] = {}
 
         output["timestamp"] = log_record["timestamp"]
         output["service"] = log_record["service"]

{hexkit-8.4.1 → hexkit-8.5.0}/src/hexkit/protocols/dao.py

@@ -243,10 +243,10 @@ class Dao(typing.Protocol[Dto]):
         It is expected that at most one resource matches the constraints.
         An exception is raised if no or multiple hits are found.
 
-        The values in the mapping are used to filter the resources, these are
-        assumed to be standard JSON scalar types. Particularly, UUIDs and datetimes
-        must be represented as strings. The behavior for non-scalars types depends
-        on the specific provider.
+        The values in the mapping are used to filter the resources. Provide them
+        using the same Python types as the corresponding DTO model fields, e.g. a
+        UUID object for a UUID field and a datetime object for a datetime field.
+        The behavior for non-scalar values depends on the specific provider.
 
         Args:
             mapping:
@@ -275,10 +275,10 @@ class Dao(typing.Protocol[Dto]):
     ) -> "FindResult[Dto]":
         """Find all resources that match the specified mapping.
 
-        The values in the mapping are used to filter the resources, these are
-        assumed to be standard JSON scalar types. Particularly, UUIDs and datetimes
-        must be represented as strings. The behavior for non-scalar types depends
-        on the specific provider.
+        The values in the mapping are used to filter the resources. Provide them
+        using the same Python types as the corresponding DTO model fields, e.g. a
+        UUID object for a UUID field and a datetime object for a datetime field.
+        The behavior for non-scalar values depends on the specific provider.
 
         Args:
             mapping:

{hexkit-8.4.1 → hexkit-8.5.0}/src/hexkit/protocols/objstorage.py

@@ -20,7 +20,7 @@
 
 import re
 from abc import ABC, abstractmethod
-from typing import NamedTuple
+from typing import Any, NamedTuple
 
 __all__ = ["ObjectStorageProtocol", "PresignedPostURL"]
 
@@ -214,8 +214,8 @@ class ObjectStorageProtocol(ABC):
         start at 1, not 0.
 
         Raises:
-            ValueError if `max_parts` or `first_part_no` are invalid.
-            MultiPartUploadNotFoundError if no upload with `upload_id` exists.
+            ValueError: if `max_parts` or `first_part_no` are invalid.
+            MultiPartUploadNotFoundError: if no upload with `upload_id` exists.
         """
         self._validate_bucket_id(bucket_id)
         self._validate_object_id(object_id)
@@ -278,6 +278,14 @@ class ObjectStorageProtocol(ABC):
         self._validate_object_id(object_id)
         return await self._get_object_size(bucket_id=bucket_id, object_id=object_id)
 
+    async def get_object_metadata(
+        self, *, bucket_id: str, object_id: str
+    ) -> dict[str, Any]:
+        """Returns object metadata without downloading the actual object."""
+        self._validate_bucket_id(bucket_id)
+        self._validate_object_id(object_id)
+        return await self._get_object_metadata(bucket_id=bucket_id, object_id=object_id)
+
     async def copy_object(
         self,
         *,
@@ -310,6 +318,9 @@ class ObjectStorageProtocol(ABC):
     async def delete_object(self, *, bucket_id: str, object_id: str) -> None:
         """Delete an object with the specified id (`object_id`) in the bucket with the
         specified id (`bucket_id`).
+
+        Deleting an object that does not exist succeeds silently. However, a
+        `BucketNotFoundError` is raised if the bucket does not exist.
         """
         self._validate_bucket_id(bucket_id)
         self._validate_object_id(object_id)
@@ -492,8 +503,8 @@ class ObjectStorageProtocol(ABC):
         start at 1, not 0.
 
         Raises:
-            ValueError if `max_parts` or `first_part_no` are invalid.
-            MultiPartUploadNotFoundError if no upload with `upload_id` exists.
+            ValueError: if `max_parts` or `first_part_no` are invalid.
+            MultiPartUploadNotFoundError: if no upload with `upload_id` exists.
         """
         ...
 
@@ -508,6 +519,7 @@ class ObjectStorageProtocol(ABC):
         *To be implemented by the provider. Input validation is done outside of this
         method.*
         """
+        ...
 
     @abstractmethod
     async def _get_object_download_url(
@@ -530,6 +542,7 @@ class ObjectStorageProtocol(ABC):
         *To be implemented by the provider. Input validation is done outside of this
         method.*
         """
+        ...
 
     @abstractmethod
     async def _get_object_size(self, *, bucket_id: str, object_id: str) -> int:
@@ -541,6 +554,13 @@ class ObjectStorageProtocol(ABC):
         """
         ...
 
+    @abstractmethod
+    async def _get_object_metadata(
+        self, *, bucket_id: str, object_id: str
+    ) -> dict[str, Any]:
+        """Returns object metadata without downloading the actual object."""
+        ...
+
     @abstractmethod
     async def _does_object_exist(
         self, *, bucket_id: str, object_id: str, object_md5sum: str | None = None
@@ -585,6 +605,9 @@ class ObjectStorageProtocol(ABC):
         """Delete an object with the specified id (`object_id`) in the bucket with the
         specified id (`bucket_id`).
 
+        Deleting an object that does not exist succeeds silently. However, a
+        `BucketNotFoundError` is raised if the bucket does not exist.
+
         *To be implemented by the provider. Input validation is done outside of this
         method.*
         """

{hexkit-8.4.1 → hexkit-8.5.0}/src/hexkit/providers/akafka/provider/daosub.py

@@ -38,6 +38,8 @@ from hexkit.providers.akafka.provider.eventsub import (
     ComboTranslator as TranslatorConverter,  # for backwards compatibility
 )
 
+log = logging.getLogger(__name__)
+
 
 class KafkaOutboxSubscriber(InboundProviderBase):
     """Apache Kafka-specific provider using translators that implement the
@@ -76,7 +78,7 @@ class KafkaOutboxSubscriber(InboundProviderBase):
 
         if config.kafka_enable_dlq and dlq_publisher is None:
             error = ValueError("A publisher is required when the DLQ is enabled.")
-            logging.error(error)
+            log.error(error)
             raise error
 
         async with KafkaEventSubscriber.construct(

{hexkit-8.4.1 → hexkit-8.5.0}/src/hexkit/providers/akafka/provider/eventpub.py

@@ -45,6 +45,8 @@ from hexkit.providers.akafka.provider.utils import (
     generate_ssl_context,
 )
 
+log = logging.getLogger(__name__)
+
 RESERVED_HEADERS = ["type", "correlation_id", "event_id"]
 
 
@@ -198,7 +200,7 @@ class KafkaEventPublisher(EventPublisherProtocol):
                 raise
 
             correlation_id = new_correlation_id()
-            logging.info("Generated new correlation ID: %s.", correlation_id)
+            log.info("Generated new correlation ID: %s.", correlation_id)
 
         # Create a shallow copy of the headers
         headers_copy = dict(headers)  # used for validation and logging only
@@ -220,12 +222,12 @@ class KafkaEventPublisher(EventPublisherProtocol):
                 f"The '{header}' header shouldn't be supplied, but was."
                 f" Overwriting old value ({old_value}) with {headers_copy[header]}."
             )
-            logging.warning(log_msg, extra={header: old_value})
+            log.warning(log_msg, extra={header: old_value})
 
         await self._producer.send_and_wait(
             topic, key=key, value=payload, headers=encoded_headers_list
         )
-        logging.info(
+        log.info(
             "Published event: topic=%s, type=%s, key=%s, event_id=%s.",
             topic,
             type_,