openquartz/easy-event

EasyEvent is a Spring Boot-based event bus framework that provides reliable, transactional event publishing and handling with support for synchronous and asynchronous dispatch. It features a pluggable architecture for event transfer via Kafka, RabbitMQ, RocketMQ, or Disruptor, alongside robust persistence, distributed locking, and compensation mechanisms for failed deliveries. The system includes a dedicated administrative console for monitoring event states, managing retries, and viewing real-time statistics.

23 changes.

This period established the foundational architecture of the EasyEvent project, introducing the core event bus, storage, and transfer layers with support for JDBC persistence and multiple message brokers including Kafka, RocketMQ, and Disruptor. It also implemented essential cross-cutting concerns such as distributed locking, trace-aware concurrency, structured exception handling, and Jackson-based serialization. The work culminated in the creation of Spring Boot starters and example applications to demonstrate the framework's capabilities.

9 changes.

This period focused on extending the framework's architecture to support Service-Oriented Architecture (SOA) events and integrating RabbitMQ as a transport mechanism. Key developments included defining the SoaEvent interface, implementing RocketMQ-backed SOA event centers, and adding comprehensive RabbitMQ modules for both event transfer and standalone examples. The work also involved establishing database schema support for the event bus and providing concrete usage examples for order completion scenarios.

4 changes.

This period focused on launching the EasyEvent Admin module, introducing a Spring Boot backend and Vue 3 frontend for event monitoring, management, and statistics. The work included implementing REST APIs for event lifecycle operations with role-based security, alongside a localized user interface with internationalization support. Regression tests were also added to the common module to ensure stability of core utilities and data handling.

This location introduces a new example application demonstrating the EasyEvent Disruptor integration. It provides a Spring Boot starter, an HTTP controller for publishing synchronous, asynchronous, and batch events, and several event handlers illustrating concurrent filtering, transaction joining, and RPC-style handling. The example also includes a local ID generator and an event publisher wrapper to showcase core event-driven capabilities.

easyevent-example/easyevent-example-disruptor/src/main/java · high confidence

This change introduces a new Kafka-based transfer module for the EasyEvent framework. It adds a Kafka producer (KafkaTransferProducer) for sending events with synchronous and asynchronous modes, and a Kafka consumer (KafkaEventTrigger) for receiving and processing events. The implementation includes configuration classes for common Kafka settings and trigger-specific consumer properties, error code definitions, and unit tests to verify consumer behavior and trigger latch logic.

easyevent-transfer/easyevent-transfer-kafka · high confidence

Introduces a new example application that demonstrates how to configure and use the EasyEvent framework with Kafka for event transfer. The example includes a Spring Boot starter, an event controller for publishing synchronous, asynchronous, and batch events, a test event model, and a handler class illustrating concurrent and standard event processing. It also provides a comprehensive application.properties configuration file detailing Kafka consumer/producer settings, thread pool parameters, and JDBC storage options.

easyevent-example/easyevent-example-kafka · high confidence

The easyevent-transfer-rabbitmq module now provides a complete RabbitMQ integration for event transfer. It introduces RabbitMqEventSender and RabbitMqEventTrigger to publish and consume events via RabbitMQ, backed by RabbitMqTransferProducer and RabbitMqTransferConsumer. Producers publish to topic exchanges (or the default exchange) with persistent text/plain messages, while consumers use manual acknowledgments: valid messages are acked, and blank payloads or handler failures are nacked without requeue to avoid tight loops. Configuration is driven by RabbitMqCommonProperty (host, port, credentials, virtual host, async/timeout/retry/threading settings) and RabbitMqTriggerProperty (per-consumer-group queue/exchange/routing-key, concurrency, QoS, and retry behavior). Error handling includes RabbitMqTransferErrorCode codes (RABBITMQ-001/002/003) and unit tests verify ack/nack behavior, callback invocation, and thread-safe channel access.

easyevent-transfer/easyevent-transfer-rabbitmq · high confidence

A new example module has been added to demonstrate integrating the EasyEvent framework with RabbitMQ. This includes a Spring Boot application entry point, a REST controller for publishing test events, and an event handler to process them. The module also provides a configuration file setting up RabbitMQ connection details (host, port, credentials) and defining consumer groups, queues, and exchanges for event transfer.

easyevent-example/easyevent-example-rabbitmq · high confidence

This change introduces a new RabbitMQ-based transfer module for the EasyEvent starter. It adds an auto-configuration class that wires up the RabbitMQ event sender and trigger components, along with configuration properties (under the prefix \easyevent.transfer.trigger.rabbitmq\) for connection details (host, port, credentials, virtual host), production settings (async mode, timeout, retry count), and consumer definitions (queue, exchange, routing key, concurrency, retry policies). The auto-configuration is registered via \spring.factories\ to enable automatic setup when RabbitMQ classes are on the classpath.

easyevent-spring-boot-starter/easyevent-spring-boot-starter-rabbitmq · high confidence

This module introduces a new RocketMQ-backed implementation for the Service-Oriented Architecture (SoA) event system. It provides a \RocketSoaEventCenter\ for publishing events to a configurable RocketMQ topic and a \SoaRocketMqEventTrigger\ for consuming them with cluster-based, concurrent processing, configurable retry/delay logic, and idempotency checks against the event storage. An auto-configuration class wires up the RocketMQ producer and consumer beans, and the starter registers itself via Spring Boot's auto-configuration mechanism.

easyevent-spring-boot-starter-soa/easyevent-spring-boot-starter-soa-rocketmq · high confidence

This module introduces a new RocketMQ adapter for the EasyEvent transfer layer, enabling event publishing and consumption via Apache RocketMQ. It includes a sender (RocketMqEventSender) that supports both synchronous and asynchronous message delivery, and a trigger (RocketMqEventTrigger) that consumes messages using push consumers with configurable groups, topics, tags, and thread pools. The implementation handles message routing, serialization, and batch sending, while also providing robust retry logic with configurable delay levels for failed or rate-limited consumption. Configuration is managed through dedicated property classes for common settings (host, timeout, async mode) and trigger-specific consumer properties.

easyevent-transfer/easyevent-transfer-rocketmq · high confidence

The SOA publisher example now includes a Spring Boot application that exposes an HTTP endpoint to publish events. Specifically, the new \OrderController\ listens on POST /order/complete, accepts an order ID, and asynchronously publishes an \OrderCompletedEvent\ via the \EventPublisher\. The example is configured to use RocketMQ as the event center for SOA communication, with connection details for the broker, topic, and producer/consumer groups defined in \application.properties\.

easyevent-example/easyevent-example-soa/easyevent-example-soa-publisher · high confidence

The RocketMQ starter now includes \RocketMqTransferAutoConfiguration\ and \RocketTransferProperties\, enabling automatic wiring of RocketMQ producers, consumers, and event triggers based on \easyevent.transfer.trigger.rocketmq\ configuration. Similarly, the Kafka starter adds \KafkaTransferAutoConfiguration\ and \KafkaTransferProperties\ to auto-configure Kafka-based event sending and triggering via \easyevent.transfer.trigger.kafka\. These changes allow users to enable RocketMQ or Kafka event transfer simply by adding the respective starter dependencies and configuring the properties, without manual bean setup.

easyevent-spring-boot-starter/easyevent-spring-boot-starter-rocketmq · high confidence

The \easyevent-common\ module now includes a suite of utility classes in the \com.openquartz.easyevent.common.utils\ package. This adds \Asserts\ for standardized exception throwing with error codes, \DataUtils\ for validating database operation counts, and \JSONUtil\ for serializing and deserializing objects using the internal Jackson-based \JsonFacade\. Additional utilities such as \CollectionUtils\, \DateUtils\, \ExceptionUtils\, \StringUtils\, and \VersionUtils\ are also introduced to support common application tasks.

easyevent-common/src/main/java/com/openquartz/easyevent/common/utils · high confidence

The example application now includes a default \application.properties\ file that configures the event storage (JDBC with HikariCP and MySQL), compensation settings, notification behavior, and thread pool parameters specifically for the Disruptor-based event transfer trigger.

easyevent-example/easyevent-example-disruptor/src/main/resources · high confidence

The Disruptor starter now includes a new auto-configuration module that automatically registers a Disruptor-based event sender when the Disruptor library is on the classpath. This allows users to enable high-performance event transfer via the Disruptor pattern without manual bean setup, with configurable thread pools, buffer sizes, and thread prefixes under the easyevent.transfer.trigger.disruptor prefix.

easyevent-spring-boot-starter/easyevent-spring-boot-starter-disruptor · high confidence

The example application now includes an \OrderCompletedEvent\ class that implements the \SoaEvent\ interface, enabling the system to publish and consume order completion events via the SOA (Service-Oriented Architecture) mechanism. This change introduces the necessary event structure, including order number and completion time fields, and defines the service identity constants required for SOA routing.

easyevent-example/easyevent-example-soa/easyevent-example-soa-event · high confidence

A new \CommonConstants\ class has been introduced in the \easyevent-common\ module to centralize shared string literals. This includes constants for matching expressions (\\*\), delimiters (comma, dot, slash, line separator), and specific identifiers like \datasource\ and RocketMQ sub-expression splitters, providing a single source of truth for these values across the application.

easyevent-common/src/main/java/com/openquartz/easyevent/common/constant · high confidence

The \easyevent-common\ module now includes a new \reflect\ package containing utilities for Java reflection, including \TypeToken\ for capturing and resolving generic types, \Invokable\ for wrapping methods and constructors, \ForwardingCollection\/\Set\ for delegating collection operations, and \ReflectionUtils\ for caching and finding methods and fields. These classes provide foundational support for generic type handling and reflection-based operations within the library.

easyevent-common/src/main/java/com/openquartz/easyevent/common/utils/reflect · high confidence

The concurrent package now includes a suite of classes to support distributed tracing and context propagation across threads. This introduces a TraceContext for managing thread-local trace data (such as traceId and sourceEventId), a TraceRunnable wrapper to carry this context, and a TraceThreadPoolExecutor that automatically propagates MDC and trace context from the submitting thread to worker threads. Additionally, a DirectExecutor delegates to a traced thread pool, and a ThreadFactoryBuilder provides a fluent API for configuring thread properties with validation.

easyevent-common/src/main/java/com/openquartz/easyevent/common/concurrent · high confidence

The easyevent-transfer-disruptor module now provides a new event transfer mechanism using the LMAX Disruptor library. This implementation introduces a high-performance, lock-free ring buffer pipeline for publishing and consuming events, featuring configurable thread pools and buffer sizes via DisruptorTriggerProperty. The sender ensures events are persisted to storage before being published to the disruptor ring buffer, with transactional callbacks marking events as sent or failed. A dedicated event handler processes events with distributed locking support to prevent duplicate processing, and comprehensive unit tests verify the send, retry, and failure-handling logic.

easyevent-transfer/easyevent-transfer-disruptor · high confidence

The RocketMQ example application now includes a default \application.properties\ file that configures the local MySQL database connection, sets up the EasyEvent JDBC storage and compensation settings, and defines the RocketMQ consumer groups (test1, test2, test3) and producer settings required to run the event-driven example.

easyevent-example/easyevent-example-rocketmq/src/main/resources · high confidence

This change introduces the foundational common model classes (EnumInterface, LifecycleBean, Pair, Range, EasyEventProperties) and transaction support interfaces (AfterTransactionCallback, InTransactionCallback, TransactionSupport) for the EasyEvent framework. It also adds a complete example application demonstrating event publishing and handling via RocketMQ, including a controller for sync/async publishing, event handlers with concurrency controls, a custom event router for topic/tag selection, and a rate-limiting control implementation using Alibaba Sentinel.

(repo-wide) · high confidence

The new easyevent-admin-server module provides a Spring Boot-based administrative interface for managing bus events. It exposes REST endpoints for paginated event listing, detailed event retrieval, updates, deletions, and manual retry operations, all protected by an interceptor that enforces role-based permissions and configurable rate limiting. Additionally, it offers a statistics dashboard API that aggregates event counts by state, 24-hour processing trends, and subscriber latency rankings. The backend supports both MySQL and H2 databases via profile-specific DAO implementations, and includes a frontend static asset bundle for the admin UI.

easyevent-admin/easyevent-admin-server · high confidence

A new management console for the EasyEvent framework is now available, providing event monitoring, manual retry capabilities, and a real-time statistics dashboard. The module consists of a Spring Boot backend (accessible on port 8088) and a Vue 3 frontend built with Vite, TypeScript, and Element Plus. Users can deploy the application locally or via Docker Compose, which provisions a MySQL 5.7 database and the admin service with pre-configured networking and environment variables.

easyevent-admin · high confidence

The easyevent-core module now provides a Google Guava-inspired EventBus implementation that supports synchronous and asynchronous event dispatching, conditional subscription filtering via SpEL expressions, and explicit transaction participation through the @Subscribe(joinTransaction=true) flag. It also introduces event compensation and retry mechanisms to handle failed deliveries, ensuring reliable event processing across distributed systems.

easyevent-core · high confidence

This location adds the JDBC implementation for the event storage layer, introducing \JdbcEventStorageServiceImpl\ as the primary persistence mechanism. It supports distributed event ID generation via a new \SnowflakeIdGenerator\ and enables database sharding through \ShardingRouter\ and \EasyEventTableGeneratorSupplier\, allowing events to be distributed across multiple tables based on their ID. The implementation includes robust lifecycle management with optimistic locking (CAS) for state transitions like \startProcessing\ and \processingFailed\ to prevent race conditions, and tracks execution times and retry counts. A custom \CustomerJdbcTemplate\ is provided to handle batch inserts with generated key retrieval.

easyevent-storage/easyevent-storage-jdbc · high confidence

The EasyEvent Spring Boot starter now provides automatic configuration for the event bus, including auto-registration of beans annotated with @EventHandler, SpEL expression support for subscriber conditions, and scheduled compensation and failure notification services. This simplifies setup by wiring core components like the event bus, storage, and transfer mechanisms via standard Spring Boot auto-configuration classes.

easyevent-spring-boot-starter/easyevent-spring-boot-starter-parent · high confidence

This change introduces the core API contract and data models for the event storage subsystem. It defines the \EventStorageService\ interface, which provides methods for saving events (single and batch), tracking send and processing lifecycle states (success, failure, completion), and querying events based on selector conditions. The update also adds the necessary domain models, including \BaseEventEntity\ and \BusEventEntity\ for storing event data and metadata, \EventBody\ for wrapping event payloads with context, and \EventContext\ for managing thread-local state such as SOA filtering and source event IDs. Additionally, it includes supporting types like \EventId\, \IdGenerator\, \EventLifecycleState\, and error codes to support the storage layer's functionality.

easyevent-storage/easyevent-storage-api · high confidence

The \easyevent-common\ module now includes a new concurrent locking subsystem (\com.openquartz.easyevent.common.concurrent.lock\) that provides distributed lock capabilities for event processing. This subsystem introduces a \LockSupport\ implementation that attempts a local lock first before acquiring a distributed lock via a pluggable \DistributedLockFactory\, ensuring safe execution of event handlers. A new \LockBizType\ enum explicitly adds support for \SOA\_EVENT\_HANDLE\, enabling distributed locking for SOA events alongside existing event handling and failure notification types. This change supports the broader migration to the \openquartz\ project structure and addresses race conditions in lock acquisition.

easyevent-common/src/main/java/com/openquartz/easyevent/common/concurrent/lock · high confidence

A new SoaEvent interface has been added to the SOA starter API module, defining a contract for service-oriented events. This interface includes a getSoaIdentify method to retrieve the SOA identifier and a default getEventKey method for event retrieval, enabling consumers to integrate with the SOA event system.

easyevent-spring-boot-starter-soa/easyevent-spring-boot-starter-soa-api · high confidence

A new SQL initialization script has been added to define the \ee\_bus\_event\_entity\ table, which serves as the storage backend for the event bus system. This table tracks event details including application ID, source ID, event class, and key, along with execution states, error counts, and trace information. It also includes specific timestamp fields to monitor execution lifecycle events such as start time, success time, and effective processing windows, supported by indexes for efficient querying by application, state, and owner.

scripts · high confidence

The library now provides a standardized exception handling mechanism through the new \EasyEventException\ class and the \EasyEventErrorCode\ interface. This allows developers to throw and catch exceptions with specific, typed error codes (such as \CommonErrorCode\ and \DataErrorCode\) rather than generic runtime errors. The system supports parameterized error messages via placeholder replacement, enabling more informative and structured error reporting for issues like illegal parameters, data operation failures, or thread pool misconfigurations.

easyevent-common/src/main/java/com/openquartz/easyevent/common/exception · high confidence

The SOA starter now includes an auto-configuration that registers a SoaEventHandler, wiring it to all available EventBus instances and enabling SoaEvent publishing and subscription through the SoaEventCenter.

easyevent-spring-boot-starter-soa/easyevent-spring-boot-starter-soa-parent · high confidence

The admin interface now supports switching between Chinese and English via a language selector in the header, ensuring all labels, event states, and messages are localized. The Event List view displays event states using translated tags (e.g., 'Available', 'Processing', 'Failed') instead of raw codes, and the Dashboard visualizes statistics with localized chart labels. Event details and list items now show human-readable status text, and the interface includes full i18n support for common actions like search, reset, and confirm.

easyevent-admin/easyevent-admin-ui · high confidence

The serde module now uses Jackson for JSON serialization and deserialization, replacing the previous implementation. This change introduces a new \JacksonHandler\ that configures \ObjectMapper\ with UTC time zones, Java 8/Java Time modules, and case-insensitive enum support. To improve performance, the handler implements caching for compiled Java types and collection types, reducing reflection overhead during repeated serialization and deserialization operations.

easyevent-common/src/main/java/com/openquartz/easyevent/common/serde · high confidence

The \easyevent-transfer-api\ module now provides the core interfaces and abstractions for transferring events, including \EventSender\ for single and batch publishing, \EventRouter\ for topic/tag routing, and \TransferProducer\ for underlying message transport. A key behavioral improvement is the correction of a copy-paste bug in \BatchSendResult\ where failed event indexes were incorrectly added to the completed list; the new \BatchSendResultTest\ ensures that failed indexes are properly tracked in \sendFailedIndexList\, preventing events from being silently marked as successful when transmission fails.

easyevent-transfer/easyevent-transfer-api · high confidence

Added a suite of regression tests in the easyevent-common module to verify correct behavior and prevent future regressions. These tests cover SQL schema index definitions, Maven parent version consistency across modules, ThreadFactoryBuilder validation, TraceContext state management, distributed and local locking logic, Jackson date serialization thread safety, DataUtils error code accuracy, and IP utility null-safety.

easyevent-common/src/test · high confidence

This change introduces the build configuration files for the EasyEvent project, establishing the dependency structure for the core library, Spring Boot starters (Disruptor, Kafka, RabbitMQ, RocketMQ, SOA), the admin server, and example applications. It defines the required libraries such as Spring Boot, MyBatis-Plus, MySQL, H2, Vue 3, Element Plus, and various message brokers, enabling the project to be built and run.

(dependencies) · high confidence

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

• CAI 41 → 44 (+3.7)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 97 → 98 (+0.9)
• Architecture 100 → 98 (-1.5)
• Maturity 62 → 62 (+0.0)
• Readiness 15 → 24 (+8.6)
• Security 85 → 86 (+1.0)
• Accessibility 48 → 46 (-1.5)

• Change coupling: KafkaTransferAutoConfiguration.java ↔ RocketMqTransferAutoConfiguration.java (easyevent-spring-boot-starter/easyevent-spring-boot-starter-kafka/src/main/java/com/openquartz/easyevent/starter/kafka/spring/boot/autoconfig/KafkaTransferAutoConfiguration.java)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (easyevent-admin/easyevent-admin-server/src/main/java/com/openquartz/easyevent/admin/controller/StatsController.java)
• Duplicated block (10 lines × 2) (easyevent-spring-boot-starter-soa/easyevent-spring-boot-starter-soa-rocketmq/src/main/java/com/openquartz/easyevent/starter/soa/rocketmq/SoaRocketMqEventTrigger.java)
• Duplicated block (12 lines × 4) (easyevent-core/src/main/java/com/openquartz/easyevent/core/compensate/EventCompensateServiceImpl.java)
• Duplicated block (14 lines × 2) (easyevent-spring-boot-starter-soa/easyevent-spring-boot-starter-soa-rocketmq/src/main/java/com/openquartz/easyevent/starter/soa/rocketmq/SoaRocketMqEventTrigger.java)
• Duplicated block (16 lines × 2) (easyevent-core/src/main/java/com/openquartz/easyevent/core/dispatcher/Dispatcher.java)
• Duplicated block (17 lines × 2) (easyevent-transfer/easyevent-transfer-rabbitmq/src/main/java/com/openquartz/easyevent/transfer/rabbitmq/common/RabbitMqTransferProducer.java)
• Duplicated block (5 lines × 2) (easyevent-storage/easyevent-storage-jdbc/src/main/java/com/openquartz/easyevent/storage/jdbc/mapper/impl/BusEventEntityMapperImpl.java)
• Duplicated block (5 lines × 2) (easyevent-transfer/easyevent-transfer-kafka/src/main/java/com/openquartz/easyevent/transfer/kafka/common/KafkaTransferProducer.java)
• Duplicated block (5 lines × 2) (easyevent-transfer/easyevent-transfer-kafka/src/main/java/com/openquartz/easyevent/transfer/kafka/common/KafkaTransferProducer.java)
• Duplicated block (6 lines × 2) (easyevent-admin/easyevent-admin-server/src/main/java/com/openquartz/easyevent/admin/dao/BusEventDaoH2.java)
• Duplicated block (6 lines × 2) (easyevent-core/src/main/java/com/openquartz/easyevent/core/SubscriberRegistry.java)
• Duplicated block (7 lines × 2) (easyevent-admin/easyevent-admin-server/src/main/java/com/openquartz/easyevent/admin/dao/BusEventDaoH2.java)
• Duplicated block (7 lines × 2) (easyevent-admin/easyevent-admin-server/src/main/java/com/openquartz/easyevent/admin/dao/BusEventDaoH2.java)
• Duplicated block (7 lines × 2) (easyevent-spring-boot-starter-soa/easyevent-spring-boot-starter-soa-rocketmq/src/main/java/com/openquartz/easyevent/starter/soa/rocketmq/config/RocketSoaEventAutoConfiguration.java)
• Duplicated block (7 lines × 2) (easyevent-spring-boot-starter/easyevent-spring-boot-starter-parent/src/main/java/com/openquartz/easyevent/starter/spring/boot/autoconfig/EasyEventCreatorAutoConfiguration.java)
• Duplicated block (7 lines × 2) (easyevent-storage/easyevent-storage-jdbc/src/main/java/com/openquartz/easyevent/storage/jdbc/mapper/impl/BusEventEntityMapperImpl.java)
• Duplicated block (7 lines × 2) (easyevent-transfer/easyevent-transfer-kafka/src/main/java/com/openquartz/easyevent/transfer/kafka/common/KafkaTransferProducer.java)
• …and 22 more

• AsyncEventHandlerAdapter.handle (cognitive 17) (easyevent-core/src/main/java/com/openquartz/easyevent/core/trigger/AsyncEventHandlerAdapter.java)
• ClassTooLong: TypeToken (easyevent-common/src/main/java/com/openquartz/easyevent/common/utils/reflect/TypeToken.java)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no architecture or design documentation (README.md)
• Duplicated block (10 lines × 2) (easyevent-admin/easyevent-admin-server/src/main/java/com/openquartz/easyevent/admin/dao/BusEventDaoH2.java)
• Duplicated block (10 lines × 2) (easyevent-admin/easyevent-admin-server/src/main/java/com/openquartz/easyevent/admin/dao/BusEventDaoH2.java)
• Duplicated block (10 lines × 2) (easyevent-spring-boot-starter/easyevent-spring-boot-starter-parent/src/main/java/com/openquartz/easyevent/starter/spring/boot/autoconfig/EasyEventCreatorAutoConfiguration.java)
• Duplicated block (10 lines × 3) (easyevent-admin/easyevent-admin-server/src/main/java/com/openquartz/easyevent/admin/controller/StatsController.java)
• Duplicated block (10–11 lines × 2) (easyevent-storage/easyevent-storage-jdbc/src/main/java/com/openquartz/easyevent/storage/jdbc/identify/SnowflakeIdGenerator.java)
• Duplicated block (10–11 lines × 2) (easyevent-transfer/easyevent-transfer-rocketmq/src/main/java/com/openquartz/easyevent/transfer/rocket/common/RocketMqProducer.java)
• Duplicated block (11 lines × 2) (easyevent-storage/easyevent-storage-jdbc/src/main/java/com/openquartz/easyevent/storage/jdbc/mapper/impl/BusEventEntityMapperImpl.java)
• Duplicated block (11 lines × 3) (easyevent-admin/easyevent-admin-server/src/main/java/com/openquartz/easyevent/admin/dao/BusEventDaoH2.java)
• Duplicated block (12 lines × 2) (easyevent-admin/easyevent-admin-server/src/main/java/com/openquartz/easyevent/admin/dao/BusEventDaoH2.java)
• Duplicated block (12 lines × 2) (easyevent-storage/easyevent-storage-jdbc/src/main/java/com/openquartz/easyevent/storage/jdbc/mapper/impl/BusEventEntityMapperImpl.java)
• Duplicated block (13 lines × 2) (easyevent-spring-boot-starter-soa/easyevent-spring-boot-starter-soa-rocketmq/src/main/java/com/openquartz/easyevent/starter/soa/rocketmq/config/RocketSoaEventAutoConfiguration.java)
• Duplicated block (13 lines × 2) (easyevent-spring-boot-starter/easyevent-spring-boot-starter-rocketmq/src/main/java/com/openquartz/easyevent/starter/rocketmq/spring/boot/autoconfig/RocketTransferProperties.java)
• Duplicated block (13 lines × 2) (easyevent-transfer/easyevent-transfer-kafka/src/main/java/com/openquartz/easyevent/transfer/kafka/KafkaEventTrigger.java)
• Duplicated block (14–15 lines × 2) (easyevent-transfer/easyevent-transfer-disruptor/src/main/java/com/openquartz/easyevent/transfer/disruptor/DisruptorTriggerEventSender.java)
• Duplicated block (19 lines × 4) (easyevent-common/src/main/java/com/openquartz/easyevent/common/exception/DataErrorCode.java)
• Duplicated block (20–21 lines × 2) (easyevent-spring-boot-starter-soa/easyevent-spring-boot-starter-soa-rocketmq/src/main/java/com/openquartz/easyevent/starter/soa/rocketmq/SoaRocketMqEventTrigger.java)
• …and 42 more

• 9 commits — 0 feature/other, 9 fixes

• easyevent-core/src — 3 commits
• (repo) — 2 commits
• easyevent-common/src — 2 commits
• easyevent-admin/easyevent-admin-server — 1 commit
• easyevent-transfer/easyevent-transfer-api — 1 commit

• fix: Merge pull request #8 from Siborne/fix/admin-parent-pom-version
• fix: Merge pull request #9 from Siborne/bugfix/send-result-and-utils
• fix: fix: close compensate, transfer, and lock races that drop events
• fix: fix: correct DataUtils error codes and ThreadFactoryBuilder assertion
• fix: fix: harden event lifecycle, transfer ack, and admin retry paths
• fix: fix: invoke publisher afterCompletion after event dispatch
• fix: fix: prevent failed sends from being marked as successful
• fix: fix: sync easyevent-admin parent version with root revision
• fix: test: add regression test for pom parent version consistency

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

openquartz/easy-event 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.