jgabrielfreitas/ktor-hexagonal-benchmark

Users can now run the application's full local stack—including MySQL, Zookeeper, and Kafka—using the new docker-compose.yml configuration. The project also includes a Dockerfile for containerizing the application, a .env file for local environment variables, and a load-test configuration for performance testing.

(repo-wide) · high confidence

A new Kafka consumer has been introduced to process user registration events. The implementation listens to the 'user-event' topic, deserializes incoming Avro records into UserMessageDto, and persists the user data via the UserPort interface.

primary/kafka-consumer/src/main/kotlin/com/quick/tor/kafka/consumer · high confidence

Added new files to support Kafka messaging: KafkaEnums.kt defines configuration enums for acks, batch size, command status, compression, and offset behavior; KafkaConsumer.kt provides a suspend function to consume records from a Kafka topic, handling deserialization via the schema registry and invoking callbacks for each record or error.

infrastructure/kafka/src/main/kotlin/com/quick/tor/infrastructure/consumer · high confidence

A new Kafka producer implementation was added to the infrastructure layer, enabling message production with Avro serialization and integration with a schema registry. The producer is configured with idempotence enabled by default, supports configurable acknowledgment levels, retries, compression, and batching settings, and provides a suspend-compatible dispatch function for sending records.

infrastructure/kafka/src/main/kotlin/com/quick/tor/infrastructure/producer · high confidence

New utility extensions were added to the shared common module. ObjectExtensions.kt provides convenience methods to serialize objects to JSON strings and deserialize JSON strings to specific types using Gson. StringExtension.kt adds a helper to convert strings to UUIDs.

shared/src/main/kotlin/com/quick/tor/common · high confidence

The REST layer is introduced with Ktor-based controllers and configuration. A health check endpoint is exposed at /health returning a status. User management endpoints are added under /users: GET /users/{id} to retrieve a user by UUID, POST /users to create a user, and PUT /users/{id} to update one. The API uses Koin for dependency injection and Gson for content negotiation.

primary/rest · medium confidence

The application now includes its first set of configuration files: application.conf defines the Ktor server port and module; config-common.conf sets up the MySQL database connection pool (HikariCP) and Kafka consumer/producer bootstrap servers; logback.xml configures console logging and suppresses verbose output from Jetty, Kafka, and Hikari.

main/src/main/resources · high confidence

Added a new Kafka consumer module containing a Koin-based module (KafkaConsumerModule) that initializes a background coroutine to run the user insertion consumer, and a new data transfer object (UserMessageDto) that maps Avro messages to the internal User model.

primary/kafka-consumer/src/main/kotlin/com/quick/tor/kafka · high confidence

Added a new Kafka producer implementation that enables asynchronous user notifications. The change introduces a \KafkaProducerAdapter\ to handle message dispatch, a \UserNotificationAdapter\ that serializes \UserEvent\ objects into Avro format for Kafka, and a Koin module to wire the Kafka configuration and dependencies. This provides the infrastructure for publishing user events to a Kafka topic named 'user-event-created'.

secondary/kafka-producer · high confidence

The application now supports storing and retrieving user and event data in a MySQL database. This change introduces database access adapters for users and events, along with the necessary repository interfaces and implementations to persist user profiles and user-generated events. Additionally, Flyway database migration scripts are added to automatically create the 'users' and 'events' tables on startup.

secondary/database-layer · high confidence

Users gain a new transactional execution model for business logic, defined by the new TransactionService interface and the RequiresTransactionContext/StartsNewTransaction annotations in Transactional.kt, which enforce transactional context for operations. Additionally, a new SharedModule registers core infrastructure components (Logger, EnvironmentVariables, ConfigRepository, ApplicationConfig) via Koin dependency injection, providing a centralized configuration and logging setup for the shared module.

shared/src/main/kotlin/com/quick/tor · medium confidence

The application now uses a new configuration system in the shared module, introducing a ConfigRepository that loads environment-specific and common configuration files (config-$deployment.conf and config-common.conf) using the Typesafe Config library. This allows the application to dynamically load settings based on the APP\_DEPLOYMENT\_ENV environment variable, providing a structured way to manage application configuration across different deployment environments.

shared/src/main/kotlin/com/quick/tor/config · high confidence

Adds the ApplicationMain.kt file which serves as the entry point for the application. It configures the Ktor server using the Netty engine on port 8090, initializes Koin dependency injection with specific modules, and triggers Flyway database migrations and Kafka consumer installation.

main/src/main/kotlin · high confidence

A new logging abstraction has been added to the shared module, defining a Logger interface and a LoggerImpl implementation backed by KotlinLogging. This provides a standardized way to log informational and error messages throughout the application.

shared/src/main/kotlin/com/quick/tor/log · high confidence

A new UserUseCase class has been added to handle user operations including save, findById, and update. The implementation integrates with a TransactionService to wrap operations in transactions, utilizes secondary ports for data access and notifications, and includes logging and error handling for event processing.

domain/src/main/kotlin/com/quick/tor/usecases/user · high confidence

The application now includes a new domain layer that defines the core business models and structure for user management. This includes a User data class representing user details and notification status, a UserEvent model for tracking user-related events, and a set of domain-specific exceptions (UserNotificationException, UserNotFoundException, SomeDomainException). Additionally, a Koin dependency injection module (DomainModule) is introduced to wire up the UserUseCase with its required ports and services, establishing the foundation for user-related business logic.

domain · high confidence

The project now includes a Gradle wrapper configuration file (gradle-wrapper.properties) that specifies the use of Gradle version 7.1.1. This ensures consistent build environments across all users by pinning the Gradle distribution URL and storage paths.

gradle · high confidence

The user domain layer now exposes three new secondary ports: UserDataAccessPort for user persistence and idempotency checks, UserEventDataAccessPort for saving and deleting user events, and UserNotificationPort for emitting user events. These interfaces define the contracts for how the user use cases interact with external systems, enabling the application to manage user data, track events, and trigger notifications.

domain/src/main/kotlin/com/quick/tor/usecases/user/port · high confidence

Added unit tests for the user domain layer, including a new Common.kt file with shared test fixtures and a new UserUseCaseTest.kt file that verifies the save and update behaviors of the UserUseCase, including interactions with notification, data access, and event data access ports.

domain/src/test/kotlin/com/quick/tor/usecases/user · high confidence

The project is initialized with a multi-module Gradle build system, establishing a hexagonal architecture with modules for domain, shared utilities, REST API, database layer, and Kafka integration. The configuration defines specific versions for key libraries including Ktor 1.6.4, Kotlin 1.6.20, Exposed, HikariCP, Flyway, and various Kafka clients, setting the foundation for the application's dependencies.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 60 → 59 (-0.9)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 99 (-1.1)
• Architecture 100 → 89 (-11.4)
• Maturity 55 → 55 (+0.0)
• Readiness 43 → 43 (+0.0)
• Security 89 → 91 (+1.6)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High: security finding (details withheld)
• High: security finding (details withheld)
• No exposed public API
• Test reliability not included
• single-maintainer — knowledge-concentration (bus factor) risk

• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no usage examples (README.md)
• High IaC: WD-COMPOSE-0002 (docker-compose.yml)
• High IaC: WD-COMPOSE-0002 (platform/docker/docker-compose.yml)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Medium IaC: WD-COMPOSE-0002 (docker-compose.yml)
• Medium IaC: WD-COMPOSE-0002 (docker-compose.yml)
• Medium IaC: WD-COMPOSE-0002 (docker-compose.yml)
• Medium IaC: WD-COMPOSE-0002 (platform/docker/docker-compose.yml)
• Medium IaC: WD-COMPOSE-0002 (platform/docker/docker-compose.yml)
• Medium IaC: WD-COMPOSE-0002 (platform/docker/docker-compose.yml)
• Medium IaC: WD-DOCKER-0003 (Dockerfile)
• Medium IaC: WD-DOCKER-0003 (Dockerfile)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• No ADRs found
• No dependency advisory monitoring
• TodoComment (domain/src/main/kotlin/com/quick/tor/usecases/user/UserUseCase.kt)
• TodoComment (domain/src/main/kotlin/com/quick/tor/usecases/user/UserUseCase.kt)
• …and 2 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

jgabrielfreitas/ktor-hexagonal-benchmark was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.