apache/eventmesh

Apache EventMesh is a unified event mesh runtime that manages subscriptions and delivery semantics using a message queue as a pure write-ahead log. It provides a pluggable architecture for protocol translation (HTTP, TCP, gRPC) and connector implementations to integrate with various data stores and messaging systems. The system also supports agent-to-agent communication through a dedicated gateway and streaming capabilities.

39 changes.

The project rebranded from DeFiBus to Apache EventMesh, establishing unified CloudEvents architecture and governance structures. Significant work focused on standardizing HTTP and TCP protocol models, implementing a new annotation-driven configuration framework, and introducing a robust SPI-based plugin loading system.

20 changes.

This period focused on expanding the project's client ecosystem by introducing new SDKs for Go, Rust, and C, alongside significant enhancements to the Java SDK with gRPC and CloudEvents support. Concurrently, the core architecture was refactored through a unified storage plugin SPI that standardizes offset management and capabilities, while common modules were strengthened with robust configuration conversion frameworks and centralized protocol enums.

18 changes.

This period focused on implementing a new unified connector architecture, replacing legacy libraries with standalone plugins for major data sources and sinks. It also introduced the A2A protocol support and a standalone agent runtime, enabling direct agent-to-agent communication and LLM integration. Underlying infrastructure improvements included a new binary wire format, a standalone connector runtime with durable storage, and strict architectural guards to enforce module boundaries.

The runtime now includes an embedded A2A Gateway that exposes a REST API with SSE streaming for agent-to-agent task management. This new component, located in the \a2a\ package, provides endpoints for submitting, listing, and canceling tasks, as well as long-polling and streaming task status updates. It integrates with the existing EventMesh transport layer to route messages and uses a pluggable \TaskStore\ for durable task lifecycle management. The gateway also supports optional bearer token authentication and integrates with the unified security gate for quota and access control.

eventmesh-runtime/src/main · high confidence

A new demo client (A2AGatewayDemo) has been added to the examples module, illustrating how to connect to the A2A Gateway Server (default port 10108) to list registered agents, submit synchronous and asynchronous tasks to a weather agent, and query task status.

eventmesh-examples/src/main/java/org/apache/eventmesh/a2a · high confidence

The TCP demo examples now include two new Java programs for CloudEvents: AsyncPublish, which demonstrates asynchronous message publishing to an EventMesh TCP endpoint, and SyncRequest, which demonstrates synchronous request-reply (RR) communication, including handling the response payload and checking for null values in the event format and data.

eventmesh-examples/src/main/java/org/apache/eventmesh/tcp/demo/pub/cloudevents · high confidence

A new \eventmesh-storage-memory\ plugin has been added, providing an in-memory implementation of the \MeshStoragePlugin\ interface. This plugin supports all seven storage capabilities (topic management, partition assignment, explicit offset commit, end offset query, align pull offset, deferred pop ack, and lite topics) and is intended for local development sandboxes and CI smoke runs where provisioning an external broker like Kafka or RocketMQ is undesirable. It can be selected by setting \eventmesh.storage.type=memory\ (or the environment variable \EVENTMESH\_STORAGE\_TYPE=memory\). State is process-local and lost on shutdown, so it is not suitable for production use. The plugin includes a TCK test suite to verify compliance with the storage API contract.

eventmesh-storage-plugin/eventmesh-storage-memory · high confidence

A new \Utils\ class has been added to the \eventmesh-examples\ module to provide shared helper methods for example code. This includes utilities for detecting the local IP address (with specific logic for Windows and Linux environments), reading properties files from the classpath, and constructing HTTP URLs from port and path components.

eventmesh-examples/src/main/java/org/apache/eventmesh/util · high confidence

The eventmesh-examples module now includes two new demo classes, AsyncSubscribe and SyncResponse, located in the TCP CloudEvents subscription package. These examples demonstrate how to use the EventMesh TCP client to subscribe to CloudEvents, covering both asynchronous message handling (where the handler returns empty) and synchronous request-response patterns (where the handler returns the event).

eventmesh-examples/src/main/java/org/apache/eventmesh/tcp/demo/sub/cloudevents · high confidence

The \eventmesh-common\ module now includes the generated Java classes for the CloudEvents gRPC protocol, providing the data models (\CloudEvent\, \CloudEventBatch\) and service stubs (\PublisherServiceGrpc\, \ConsumerServiceGrpc\, \HeartbeatServiceGrpc\) required for gRPC-based event communication.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/grpc/cloudevents · high confidence

The EventMesh common module now includes the generated Java classes and proto source for the AdminService gRPC interface. This adds support for two new administrative RPCs: a unary \invoke\ call and a bidirectional streaming \invokeBiStream\ call, both exchanging \Payload\ messages (containing metadata and a body) with the server. Users can now utilize the generated \AdminServiceGrpc\ stubs to communicate with EventMesh administrative endpoints via gRPC.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/grpc/adminserver, eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/grpc/proto · high confidence

A new GrpcEventMeshCloudEventProtocolResolver class has been introduced in the meshmessage protocol plugin to handle serialization and deserialization of CloudEvents via the gRPC protocol. This component bridges the internal EventMesh CloudEvent structures with the standard io.cloudevents.CloudEvent format using Protobuf, enabling support for single events, null-safe handling, and batch event processing within the Java gRPC transport layer.

eventmesh-protocol-plugin/eventmesh-protocol-meshmessage/src/main/java/org/apache/eventmesh/protocol/meshmessage/resolver/grpc · high confidence

The configuration management system now supports a wider range of data types out of the box. New converter classes have been added to handle primitive types (Character, Boolean, Byte, Short, Integer, Long, Float, Double), complex collections (List, Map, Properties), and specialized formats (Date, LocalDate, LocalDateTime, Enum, IPAddress, URI, String). This allows configuration fields of these types to be automatically parsed and validated from string-based configuration sources without requiring custom conversion logic.

eventmesh-common/src/main/java/org/apache/eventmesh/common/config/convert/converter · high confidence

The HTTP protocol resolver module now includes concrete implementations for converting HTTP publish/subscribe requests into CloudEvents. SendMessageRequestProtocolResolver handles single message sends, supporting both CloudEvents spec v0.3 and v1, while SendMessageBatchV2ProtocolResolver handles batch message sends using the V2 request format. SendMessageBatchProtocolResolver is also added as a placeholder for future batch support. These resolvers map HTTP headers and bodies to CloudEvent attributes and extensions, enabling EventMesh to process HTTP-based message publishing.

eventmesh-protocol-plugin/eventmesh-protocol-meshmessage/src/main/java/org/apache/eventmesh/protocol/meshmessage/resolver/http · high confidence

This change introduces the EventMesh C/C++ SDK, providing a new client library for C-based applications to interact with EventMesh. The SDK supports TCP communication and implements the RMB (Reliable Message Bus) API, enabling features such as message publishing, subscription, request-response (RR) patterns, and broadcast messaging. It includes a comprehensive set of header files defining the public API (e.g., \rmb\_pub.h\, \rmb\_sub.h\, \rmb\_msg.h\), configuration management via \rmb\_cfg.h\, and logging capabilities. A sample \demo.c\ and configuration file \rmb.conf\ are provided to demonstrate usage, and the build system relies on \make\ with git submodules for dependencies.

eventmesh-sdks/eventmesh-sdk-c · high confidence

This change adds the \eventmesh-protocol-a2a\ plugin, enabling EventMesh to support the A2A protocol for agent communication. It provides a Java SDK client (\A2AClient\) for registering agent cards, sending tasks, and handling streaming responses via a REST gateway. The plugin includes protocol adaptors (\A2AFrameAdaptor\, \EnhancedA2AProtocolAdaptor\) to convert between A2A JSON-RPC messages and EventMesh CloudEvents, a topic factory for structured agent discovery and task routing, and validators for agent card schemas.

eventmesh-protocol-plugin/eventmesh-protocol-a2a · high confidence

The agent module has been restructured into a standalone runtime (eventmesh-agent-runtime) that boots a streaming agent process to register with the EventMesh control plane, manage conversation history, and bridge prompts to an OpenAI-compatible LLM gateway. This release ships the first in-tree agent plugin, HttpFetchTool, which allows the agent to fetch HTTP/HTTPS URLs and return the response body as a tool result. The runtime supports extensibility via an SPI mechanism for custom tools and exposes connector-backed tools for reading and writing events, configurable through system properties and environment variables.

eventmesh-agent-plugin/eventmesh-agent-plugin-http-fetch, eventmesh-agent-runtime, eventmesh-connector-plugin/eventmesh-connector-api · high confidence

Added \Body\, \BaseRequestBody\, and \BaseResponseBody\ classes to the \eventmesh-common\ HTTP protocol package. The abstract \Body\ class provides a factory method (\buildBody\) that dispatches incoming HTTP requests to specific request body implementations (such as \SendMessageRequestBody\, \RegRequestBody\, and \HeartbeatRequestBody\) based on the request code, while \BaseResponseBody\ standardizes the structure for HTTP responses including return code, message, and timestamp.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/http/body · high confidence

This change adds a new set of common utility classes, enums, and wrappers to the \eventmesh-common\ module to support the Java SDK's gRPC protocol implementation. Specifically, it introduces \EventMeshCloudEventUtils\ for handling CloudEvent attributes, \ClientType\ and \GrpcType\ enums to define client roles and gRPC modes, \StatusCode\ for standardized error codes, and wrapper classes (\EventMeshCloudEventWrapper\, \BatchEventMeshCloudEventWrapper\) to encapsulate CloudEvent payloads for transmission. These components provide the foundational data structures and helper methods required for the gRPC communication layer.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/grpc/common · high confidence

The \eventmesh-common\ module now includes a new \org.apache.eventmesh.common.protocol.tcp\ package containing the core data structures for the TCP protocol. This adds the \Command\ enum defining message types (such as heartbeat, subscription, and RR requests), the \OPStatus\ enum for operation results, and model classes including \Package\ (the wire format with Header and body), \Header\ (metadata and properties), \EventMeshMessage\ (message payload), \Subscription\, \RedirectInfo\, and \UserAgent\ (client identity). These classes provide the foundational types for serializing and deserializing TCP traffic.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/tcp · high confidence

Adds the \eventmesh-sdks/eventmesh-sdk-go\ module, providing the foundational Go client library for EventMesh. This release includes core protocol structures for HTTP, TCP, and CloudEvents, along with utilities for unique ID generation (Snowflake and UUID), message serialization, and standard build/lint tooling (Makefile, golangci-lint).

eventmesh-sdks/eventmesh-sdk-go · high confidence

Adds the \eventmesh-sdk-rust\ module, providing a new Rust client for EventMesh that communicates via gRPC. The SDK supports publishing, batch publishing, and request-reply messaging using both standard EventMesh messages and CloudEvents (via the \cloud\_events\ feature). It includes gRPC producer and consumer implementations, protobuf definitions for CloudEvents and the EventMesh service, and example code for quickstart usage.

eventmesh-sdks/eventmesh-sdk-rust · high confidence

The \eventmesh-common\ module now includes the \org.apache.eventmesh.common.protocol.http\ package, introducing \HttpCommand\, \HttpEventWrapper\, and \WebhookProtocolTransportObject\ as the core HTTP protocol transport types. \HttpCommand\ provides a mechanism to construct HTTP responses from requests, including support for custom status codes and automatic header management. \HttpEventWrapper\ offers a similar abstraction for HTTP events, utilizing maps for headers and a byte array for the body, while \WebhookProtocolTransportObject\ defines the structure for webhook cloud events. These classes are marked as internal legacy types, restricting their usage to the Java SDK and the \eventmesh-protocol-meshmessage\ module to maintain architectural boundaries.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/http · high confidence

The eventmesh-spi module now provides a new extension loading mechanism via the EventMeshExtensionFactory, which supports both singleton and prototype instance lifecycles for plugins. This change introduces the EventMeshSPI annotation to mark extension interfaces, the EventMeshExtensionType enum to categorize extensions (such as connectors, storage, and metrics), and the ExtensionException class for error handling. Users can now leverage this factory to dynamically load and manage plugin instances based on configuration and type.

eventmesh-spi/src/main/java/org/apache/eventmesh/spi · high confidence

The eventmesh-connector-runtime module now provides a standalone process for running connectors, launched via the new start-connector.sh script. This runtime supports both static configuration via system properties and dynamic assignment from the EventMesh runtime scheduler. It introduces a local HTTP admin server (configurable via CONNECTOR\_ADMIN\_PORT) exposing /health, /offsets, /metrics, and /control endpoints for monitoring and lifecycle management. To prevent data loss, the runtime implements per-event publish isolation in the source loop and per-delivery ACK isolation in the sink loop, alongside configurable offset persistence using RocksDB, in-memory, or remote storage modes.

eventmesh-connector-runtime · high confidence

The storage API now exposes a single, unified \MeshStoragePlugin\ interface that treats the underlying message queue as a persistent FIFO write-ahead log, removing exposure of internal concepts like producer/consumer groups and tags. EventMesh now owns subscription and offset management, pulling messages via \poll\ and committing distribution offsets explicitly. The API introduces a capability marker system (\StorageCapabilities\) allowing backends to declare optional features such as topic management, partition assignment, end-offset querying, pull-offset alignment, deferred POP acknowledgments, and RocketMQ 5.x Lite Topic support. This change also includes new interfaces for lifecycle management, admin operations, and async consumption contexts, alongside a Test Compatibility Kit (TCK) to ensure backend implementations adhere to the new contract.

eventmesh-storage-plugin/eventmesh-storage-api · high confidence

The TCP codec module now provides a centralized \Codec\ class with nested \Encoder\ and \Decoder\ components to handle serialization and deserialization of TCP packages. The encoder constructs messages by writing a magic flag, version, length fields, and JSON-serialized headers and bodies, while the decoder parses incoming byte buffers back into \Package\ objects, including validation of the magic flag and version. This change establishes the standard binary protocol format for TCP communication within the EventMesh common library.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/tcp/codec · high confidence

Adds a new set of enumerations and constants in the \eventmesh-common\ module to standardize the HTTP protocol layer. This includes \RequestCode\ for defining operation types (such as publish, subscribe, and heartbeat), \RequestURI\ for mapping API endpoints, \ClientRetCode\ and \EventMeshRetCode\ for handling response statuses, \ClientType\ for distinguishing publishers and subscribers, \ProtocolVersion\ for versioning, and \ProtocolKey\ for header definitions. These components provide the foundational data structures required for HTTP-based message publishing and subscription operations.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/http/common · high confidence

The \eventmesh-common\ module now includes a set of new Java classes in the \org.apache.eventmesh.common.protocol.http.header.client\ package to model HTTP protocol headers for client-side interactions. This includes a base \Header\ abstract class with a factory method that dispatches to specific implementations based on the request code, as well as dedicated request and response header classes for operations such as heartbeat, registration, unregistration, subscription, and unsubscription. These classes standardize how metadata like environment, IDC, IP, and protocol version are serialized and deserialized for these specific client events.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/http/header/client · high confidence

The eventmesh-common module now includes dedicated exception classes, specifically EventMeshException and JsonException, to provide structured error handling for general runtime issues and JSON processing failures respectively. EventMeshException supports error codes and messages, while JsonException is designed for format errors, improving clarity and debugging for users encountering these specific failure modes.

eventmesh-common/src/main/java/org/apache/eventmesh/common/exception · high confidence

The eventmesh-runtime module now includes dedicated shell scripts (start.sh and stop.sh) for launching and managing the EventMeshApplication process. The start script assembles the classpath from the conf, apps, and lib directories, applies default configuration values (such as Kafka storage, ports 10105/10106, and A2A settings), and executes the main application class. The stop script provides graceful shutdown capabilities by locating the running JVM process via jps or pgrep, sending SIGTERM, and waiting up to 10 seconds for the shutdown hook to flush offsets before force-killing if necessary.

eventmesh-runtime/bin · high confidence

The \eventmesh-common\ module now includes a new set of request and response header classes for HTTP-based messaging operations. Specifically, \PushMessageRequestHeader\ and \PushMessageResponseHeader\ handle push message interactions, while \ReplyMessageRequestHeader\ and \ReplyMessageResponseHeader\ manage reply message flows. Additionally, headers for batch sending have been introduced: \SendMessageBatchRequestHeader\ and \SendMessageBatchResponseHeader\ for the standard batch API, and \SendMessageBatchV2RequestHeader\ and \SendMessageBatchV2ResponseHeader\ for the V2 batch API. These classes define the structure for protocol keys, instance metadata (cluster, IP, environment, IDC), and authentication fields, providing the data models used by the HTTP protocol layer.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/http/header/message · high confidence

The \eventmesh-common\ module now includes a new set of request and response body classes for the HTTP pub/sub protocol, enabling structured handling of message operations. This adds \PushMessageRequestBody\ and \PushMessageResponseBody\ for push notifications, \ReplyMessageRequestBody\ and \ReplyMessageResponseBody\ for message replies, and dedicated classes for single and batch message sending (\SendMessageRequestBody/ResponseBody\, \SendMessageBatchRequestBody/ResponseBody\, \SendMessageBatchV2RequestBody/ResponseBody\). These classes provide standardized fields (such as topic, content, and producer group) and utility methods for serialization, allowing the runtime to correctly parse and construct HTTP payloads for these specific message flows.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/http/body/message · high confidence

The \eventmesh-common\ module now includes a new set of request and response body classes in the \org.apache.eventmesh.common.protocol.http.body.client\ package to support client-side HTTP protocol interactions. Specifically, \HeartbeatRequestBody\ and \HeartbeatResponseBody\ handle client heartbeat reporting, while \RegRequestBody\/\RegResponseBody\ and \UnRegRequestBody\/\UnRegResponseBody\ manage topic registration and unregistration. Additionally, \SubscribeRequestBody\/\SubscribeResponseBody\ and \UnSubscribeRequestBody\/\UnSubscribeResponseBody\ are introduced to handle topic subscription and unsubscription. These classes provide structured data models with fields like \clientType\, \consumerGroup\, \topics\, and \url\, and include utility methods for JSON serialization and map conversion to facilitate communication with the EventMesh broker.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/http/body/client · high confidence

The Java SDK now includes a new \CloudEventsClient\ for the simplified runtime, enabling publish, request-reply, subscribe, and streaming operations over HTTP using CloudEvents. It also introduces a gRPC client (\EventMeshGrpcConsumer\) for traditional EventMesh communication, along with supporting classes for streaming sessions and configuration.

eventmesh-sdks/eventmesh-sdk-java/src/main · high confidence

This change introduces the \RocketMQ5RemotingStoragePlugin\, a new storage backend for EventMesh that connects to RocketMQ 5.x via direct remoting RPC (bypassing the standard gRPC client). For users, this enables message storage using RocketMQ 5.x's POP consumption mode, which handles broker-side message assignment and eliminates the need for client-side partition ownership management. The plugin also supports RocketMQ 5.5 Lite Topics (RIP-83), allowing messages to be sent to parent topics with automatic routing to Lite Topic consume queues. It implements specific capabilities including topic management, partition assignment, explicit offset committing, deferred POP acknowledgments, and Lite Topic operations, verified by a new TCK test suite.

eventmesh-storage-plugin/eventmesh-storage-rocketmq5 · high confidence

The TCP demo examples now include three new standalone client programs: AsyncPublish, which sends asynchronous messages with delays using ThreadUtils; AsyncPublishBroadcast, which demonstrates broadcasting messages to multiple subscribers; and SyncRequest, which performs synchronous request-reply interactions and logs the response. These examples utilize the EventMeshTCPClient to connect to the EventMesh broker via TCP, providing users with concrete reference implementations for different messaging patterns.

eventmesh-examples/src/main/java/org/apache/eventmesh/tcp/demo/pub/eventmeshmessage · high confidence

The eventmesh-examples module now includes three new Java demo programs—AsyncSubscribe, AsyncSubscribeBroadcast, and SyncResponse—located in the TCP subscriber package. These examples demonstrate how to use the EventMeshTCPClient to subscribe to topics using different subscription types (ASYNC, BROADCASTING, and SYNC) and modes (CLUSTERING and BROADCASTING), providing users with concrete reference implementations for handling incoming EventMeshMessages in various scenarios.

eventmesh-examples/src/main/java/org/apache/eventmesh/tcp/demo/sub/eventmeshmessage · high confidence

Added EventMeshTestUtils and UtilsConstants to the TCP examples module, providing helper methods to generate CloudEvents (v1) and EventMeshMessage packages for sync, async, and broadcast scenarios, along with centralized constants for test configuration such as ports, subsystems, and message properties.

eventmesh-examples/src/main/java/org/apache/eventmesh/tcp/common · high confidence

Added TcpMessageProtocolResolver to handle bidirectional conversion between TCP EventMeshMessage objects and CloudEvents. The resolver validates protocol parameters, maps message topics and bodies to CloudEvent subjects and data, and ensures proper JSON serialization by defaulting the data content type to application/octet-stream when not explicitly set.

eventmesh-protocol-plugin/eventmesh-protocol-meshmessage/src/main/java/org/apache/eventmesh/protocol/meshmessage/resolver/tcp · high confidence

The \eventmesh-common\ module now includes a new configuration framework (\org.apache.eventmesh.common.config\) that allows configuration classes to be defined via \@Config\ and \@ConfigField\ annotations. This framework supports loading properties from both \.properties\ and \.yaml\ files, automatically maps them to Java objects, and includes a \ConfigMonitorService\ that periodically reloads configuration values at runtime for fields marked with \reload = true\. A default \CommonConfiguration\ class is provided, establishing baseline settings for system identifiers, environment metadata, and plugin types (e.g., metaStorage, trace, metrics, security, storage, registry).

eventmesh-common/src/main/java/org/apache/eventmesh/common/config · high confidence

The \eventmesh-common\ module now includes a new \org.apache.eventmesh.common.enums\ package containing standard enumerations that define core EventMesh concepts. This adds \ComponentType\ (connector, function, mesh), \ConnectionType\ (persistent, short-lived), \ConnectorStage\ (source, sink), \EventMeshDataContentType\ (JSON), \EventMeshProtocolType\ (CloudEvents, EventMesh Message, Open Message), \HttpMethod\ (standard HTTP verbs), and \ProtocolType\ (TCP, HTTP, gRPC). These types provide a unified, type-safe way for EventMesh components to identify and handle different protocols, connection lifecycles, and data formats.

eventmesh-common/src/main/java/org/apache/eventmesh/common/enums · high confidence

The eventmesh-common module now includes a new \org.apache.eventmesh.common.config.convert\ package that provides a structured framework for converting configuration properties into strongly-typed Java objects. This change introduces a registry-based converter system (\ConverterMap\) that automatically maps configuration fields to specific converters for types such as \String\, \Integer\, \Long\, \Date\, \LocalDateTime\, \LocalDate\, \URI\, \IPAddress\, \Enum\, \List\, \Map\, and \Properties\. The system supports environment variable fallbacks for configuration keys and enforces non-empty constraints, allowing the application to more robustly parse and validate configuration data from \Properties\ sources.

eventmesh-common/src/main/java/org/apache/eventmesh/common/config/convert · high confidence

EventMesh introduces a new internal wire format, EventMeshFrame, to unify streaming and pub/sub messaging across runtime, storage, and agent components. This compact binary format replaces previous internal representations, supporting StreamRequest, StreamChunk, and CloudEvent types with a 14-byte header and key-value attributes. The change includes a pluggable codec SPI (WireCodec) with a default implementation (EventMeshFrameCodec) that can be overridden via the eventmesh.wire.codec system property. Additionally, FrameLimits are enforced at both encode and decode boundaries to prevent memory exhaustion from oversized frames, and EventMeshFrame is made immutable with defensive copying to ensure thread safety.

eventmesh-common/src/main/java/org/apache/eventmesh/common/wire · high confidence

The \eventmesh-protocol-api\ module now exposes a new \FrameAdaptor\ SPI interface for converting between external protocol formats (such as CloudEvents JSON or MeshMessage TCP) and the internal \EventMeshFrame\, decoupling protocol-specific conversion logic from the runtime. This is supported by an \EnhancedProtocolPluginFactory\ that manages protocol adaptors with lifecycle hooks, priority-based selection, and lazy loading, alongside a \ProtocolRouter\ for intelligent message routing based on preferred protocols, custom rules, and capability matching. The change also introduces \ProtocolMetrics\ for tracking operation success rates and latencies, and a dedicated \ProtocolHandleException\ for error handling, providing a more robust and observable plugin architecture for protocol integration.

eventmesh-protocol-plugin/eventmesh-protocol-api/src/main · high confidence

The \eventmesh-common\ module introduces new public SPI classes to support protocol transport and streaming calls. The \protocol\ package adds \ProtocolTransportObject\ as a base interface, \ByteTransport\ for raw byte payloads, and subscription models (\SubscriptionItem\, \SubscriptionMode\, \SubscriptionType\) with Jackson converters. The \stream\ package introduces \StreamRequest\ and \StreamChunk\ DTOs for agent runtime communication, along with \StreamEventCodec\ to serialize these objects to and from CloudEvents.

eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol · high confidence

Added a new example client (StreamingCallDemo) that demonstrates how to use the EventMesh CloudEvents client for streaming calls to registered agents. The demo illustrates two usage patterns: a single-turn call where tokens are streamed and printed as they arrive, and a multi-turn session where context is maintained across multiple prompts by reusing the same session ID. It serves as a practical reference for integrating with the new streaming architecture.

eventmesh-examples/src/main/java/org/apache/eventmesh/cloudevents · high confidence

This change introduces new source and sink connector implementations for File, Kafka, Pulsar, and RocketMQ that implement the \SourceConnector\ and \SinkConnector\ interfaces directly, removing the dependency on the legacy \openconnect\ library. For users, this means these connectors now operate as standalone plugins within the new architecture, handling CloudEvent conversion and lifecycle management (init, poll, put, commit) natively. The File connector writes/reads text lines to/from local files, while the Kafka, Pulsar, and RocketMQ connectors manage their respective client producers and consumers to bridge external message queues with the EventMesh runtime. Unit tests are included to verify the SPI contract and basic data flow for each connector.

(repo-wide) · high confidence

This release introduces a new set of source and sink connectors for EventMesh, implementing the unified \SourceConnector\ and \SinkConnector\ interfaces. The diff adds concrete implementations for HTTP (with configurable ports and paths), JDBC (supporting MySQL via prepared statements for both polling and batching), Knative (HTTP-based webhook sources and CloudEvents sinks), MongoDB (using change streams for sources and document insertion for sinks), RabbitMQ (using direct queue consumption and publishing), and Redis (using pub/sub topics). Each connector includes its own configuration files (YAML) for test setups, defining connection details like URLs, ports, queues, and topics, allowing users to integrate EventMesh with these specific data stores and protocols.

(repo-wide) · high confidence

This change introduces complete source and sink connector implementations for Canal, ChatGPT, DingTalk, Lark, and MCP under the new architecture. The Canal connector replays binlog-derived CloudEvents into MySQL as an atomic JDBC batch (sink) and consumes binlog entries from a Canal server as CloudEvents with at-least-once checkpointing (source). The ChatGPT connector exposes an HTTP endpoint to receive prompts, optionally completes them via the OpenAI REST API, and exposes results as CloudEvents (source), while its sink forwards CloudEvents to a webhook URL. The DingTalk and Lark connectors receive platform webhook pushes (robot callbacks and event subscriptions, respectively), verify signatures/tokens, and expose them as CloudEvents (source), with sinks forwarding events to their respective platform webhooks. The MCP connectors receive JSON-RPC 2.0 notifications from an MCP server as CloudEvents (source) and forward CloudEvents to an MCP server as JSON-RPC requests (sink). Test configuration files for these connectors are also added.

(repo-wide) · high confidence

The system now automatically discovers and registers the MeshMessage protocol implementation via new META-INF service files. Specifically, \org.apache.eventmesh.protocol.api.ProtocolAdaptor\ maps the \eventmeshmessage\ identifier to \MeshMessageProtocolAdaptor\, and \org.apache.eventmesh.protocol.api.FrameAdaptor\ maps \meshmessage\ to \MeshMessageFrameAdaptor\, enabling the runtime to handle this specific protocol variant without manual configuration.

eventmesh-protocol-plugin/eventmesh-protocol-meshmessage/src/main/resources · high confidence

The eventmesh-common module now enforces a clear boundary between public and internal APIs using new @Public and @Internal annotations, restricting downstream modules from importing internal implementation details. Additionally, the legacy EventMeshMessage class is marked as deprecated since version 1.13.0 and scheduled for removal, directing users to migrate to EventMeshFrame for runtime/SDK usage or the legacy TCP bridge variant.

eventmesh-common/src/main/java/org/apache/eventmesh/common · high confidence

The eventmesh-common module has been reorganized into internal sub-packages (such as internal, lifecycle, metrics, protocol.grpc, and util) to better structure helper classes and enforce dependency rules. This change introduces new internal utilities including a resettable CountDownLatch, thread management wrappers, component lifecycle interfaces, and configuration context helpers, while marking these packages as internal implementation details that are forbidden from being imported by modules outside of eventmesh-common.

(repo-wide) · high confidence

The new eventmesh-architecture-guard module introduces nine ArchUnit rules that enforce package boundaries for eventmesh-common, eventmesh-runtime, connector plugins, and storage plugins. These rules are now asserted in FAIL mode, meaning any violation breaks the build and appears as a dedicated "Architecture Guard" check in pull requests via a new CI workflow. This replaces the previous silent WARN mode, which failed to report violations due to missing logging bindings, ensuring that internal package leaks and cross-plugin dependencies are caught immediately.

eventmesh-architecture-guard · high confidence

The build process now automatically generates the \tools/dist-license/LICENSE\ and \tools/dist-license/NOTICE\ files, along with individual license texts for Go dependencies (such as xxhash, cloudevents-sdk-go, and grpc) in the \tools/dist-license/licenses/go\ directory. This ensures that all third-party components included in the distribution carry the correct copyright and license information, simplifying compliance for users redistributing the software.

tools · high confidence

The example module now uses a new \ExampleConstants\ class to centralize default values for connection details (such as the default gRPC port 10108), protocol settings, and test topic names. This change consolidates previously scattered string literals and configuration keys, ensuring consistent defaults across HTTP, TCP, and gRPC example demos.

eventmesh-examples/src/main/java/org/apache/eventmesh/common · high confidence

The runtime now ships with a new \eventmesh.properties\ file that centralizes configuration for storage backends (RocketMQ 4/5, Kafka, or in-memory), delivery topology modes (LOCAL\_STICKY\_PULL vs PARTITION\_OWNED\_PULL), and experimental connector runtime settings. A corresponding \log4j2.xml\ is added to provide default console-based logging for the EventMesh and root loggers, with Kafka and RocketMQ logs set to WARN.

eventmesh-runtime/conf · high confidence

This change introduces dedicated Dockerfiles for the EventMesh core runtime and the connector runtime, replacing previous build artifacts. The core image now runs as a non-root user (uid 10001), includes a HEALTHCHECK probing the admin port (10106), and exposes ports 10105 (traffic), 10106 (admin), and 10107 (WebSocket). The connector image similarly runs as a non-root user (uid 10002), uses process-based health checks, and exposes port 8083 for its optional admin interface. Both images are built using Gradle 8.5 with JDK 21, drop unnecessary locale packages, and persist state in mounted volumes for offset storage.

docker · high confidence

The MeshMessage protocol plugin now includes a new \MeshMessageFrameAdaptor\ that converts legacy TCP \Package\ objects directly to/from \EventMeshFrame\ objects, bypassing the previous CloudEvent intermediary path. This is complemented by a refactored \MeshMessageProtocolAdaptor\ that handles TCP, HTTP, and gRPC protocol deserialization and serialization, and a new \MeshMessageProtocolConstant\ enum defining protocol-specific constants.

eventmesh-protocol-plugin/eventmesh-protocol-meshmessage/src/main/java/org/apache/eventmesh/protocol/meshmessage · high confidence

The project has been rebranded from 'DeFiBus' to 'Apache EventMesh', updating the README, adding a Chinese translation, and establishing the official Apache governance structure via .asf.yaml. The documentation now describes a unified CloudEvents-over-MQ architecture where the message queue serves as a pure write-ahead log, with the EventMesh Runtime managing subscriptions and delivery semantics. A new maturity model (maturity.md) and capability status table are introduced to track the stability of features like the Connector Runtime and A2A agent gateway, while standard repository infrastructure files (.gitignore, .dockerignore, .licenserc.yaml) are added to support the new project structure.

(repo-wide) · high confidence

The SPI loader module has been restructured to improve how extensions are discovered and loaded. A new \EventMeshExtensionConstant\ class centralizes the metadata directory path (\META-INF/eventmesh/\). The loading logic is now split into two distinct implementations: \MetaInfExtensionClassLoader\ for loading extensions from the standard classpath, and \JarExtensionClassLoader\ for loading extensions from external plugin directories (defaulting to \./plugin\). A new \EventMeshUrlClassLoader\ provides a singleton-managed URL classloader used by the JAR loader to dynamically load plugin JARs. This change separates classpath-based discovery from external plugin loading, allowing plugins to be loaded from configurable directories outside the application classpath.

eventmesh-spi/src/main/java/org/apache/eventmesh/spi/loader · high confidence

The connector configuration system has been refactored to use a unified, type-safe hierarchy in \eventmesh-common\. A new base \Config\ class anchors a structure where \SourceConfig\ and \SinkConfig\ extend it, sharing common \PubSubConfig\ (for mesh address, subject, and credentials) and source-specific \PollConfig\ (for queue capacity and batch settings). This standardization is applied across multiple connector implementations—including HTTP, DingTalk, Lark, Knative, MCP, File, and Kafka—each now possessing dedicated source and sink configuration classes that inherit from this common model, ensuring consistent parameter handling and reducing configuration duplication.

eventmesh-common/src/main/java/org/apache/eventmesh/common/config/connector · high confidence

The Kafka and RocketMQ storage plugins now implement the new MeshStoragePlugin SPI, declaring standardized capabilities such as TopicManagement, PartitionAssignment, ExplicitOffsetCommit, and AlignPullOffset. This change aligns the pull cursor with the ACK offset on restart, ensuring that message delivery semantics are consistent and that offsets are managed explicitly by EventMesh rather than relying on underlying broker group semantics. The plugins now use the EventMeshFrame wire format for internal storage, and the RocketMQ plugin switches to a remoting-based client to avoid conflicts with the standard client library.

eventmesh-storage-plugin/eventmesh-storage-kafka, eventmesh-storage-plugin/eventmesh-storage-rocketmq · high confidence

Added test configuration properties for eventmesh-common; Added test coverage for the new Java SDK modules; Added tests for A2A Gateway, Admin Security, and Task Expiration; Added tests for EventMesh wire framing and codec round-trips; Added tests for EventMeshExtensionFactory singleton and prototype behavior; Added tests for ObjectConverter config conversion; Added tests for ProtocolPluginFactory; Added unit tests for EventMeshMessage, EventMeshThreadFactory, and ResetCountDownLatch; Added unit tests for HTTP message header classes; Added unit tests for HTTP protocol headers and bodies; Added unit tests for MeshMessageProtocolAdaptor; Added unit tests for TCP protocol codec; Added unit tests for configuration loading and validation; Added unit tests for eventmesh-common utility classes; Added unit tests for gRPC CloudEvent utility methods.

This change adds the \eventmesh-agent-plugin\ module, which implements the AgentTool SPI to allow connector plugins to be exposed as LLM tools via an independent agent process communicating through CloudEvents. It also introduces the \eventmesh-architecture-guard\ module, which uses ArchUnit to enforce that downstream modules do not access internal sub-packages of \eventmesh-common\, ensuring strict module isolation.

(dependencies) · high confidence

The project's Gradle wrapper has been updated to use Gradle 8.7 (specifically the binary distribution). This ensures that builds are executed with a consistent, modern version of the Gradle build tool, which may bring performance improvements, new features, and compatibility with newer Java versions compared to previous wrapper versions.

gradle · high confidence

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

• CAI 60 → 64 (+4.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 86 → 90 (+4.6)
• Architecture 100 → 92 (-7.6)
• Maturity 71 → 75 (+4.1)
• Readiness 70 → 56 (-14.4)
• Security 55 → 60 (+4.9)

• A2AGatewayHttpHandler.handle (cognitive 27) (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/a2a/A2AGatewayHttpHandler.java)
• A2AGatewayHttpHandler.handle (cyclomatic 23) (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/a2a/A2AGatewayHttpHandler.java)
• A2AGatewayHttpHandler.handleSubmitTask (cognitive 22) (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/a2a/A2AGatewayHttpHandler.java)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (eventmesh-sdks/eventmesh-sdk-go/go.mod)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/grpc/adminserver/AdminServiceGrpc.java)
• Duplicated block (10 lines × 2) (eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/grpc/cloudevents/PublisherServiceGrpc.java)
• Duplicated block (10 lines × 2) (eventmesh-sdks/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/grpc/producer/CloudEventProducer.java)
• Duplicated block (10 lines × 2) (eventmesh-sdks/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/tcp/impl/cloudevent/CloudEventTCPSubClient.java)
• Duplicated block (10 lines × 2) (eventmesh-spi/src/main/java/org/apache/eventmesh/spi/loader/JarExtensionClassLoader.java)
• Duplicated block (10 lines × 3) (eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/grpc/cloudevents/ConsumerServiceGrpc.java)
• Duplicated block (11 lines × 2) (eventmesh-connector-runtime/src/main/java/org/apache/eventmesh/connector/ConnectorRuntime.java)
• Duplicated block (11 lines × 2) (eventmesh-examples/src/main/java/org/apache/eventmesh/a2a/demo/ce/CloudEventsProvider.java)
• Duplicated block (11 lines × 2) (eventmesh-examples/src/main/java/org/apache/eventmesh/a2a/demo/gateway/A2AGatewayDemo.java)
• Duplicated block (11 lines × 2) (eventmesh-sdks/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/cloudevents/CloudEventsClient.java)
• Duplicated block (11 lines × 2) (eventmesh-spi/src/main/java/org/apache/eventmesh/spi/EventMeshExtensionFactory.java)
• Duplicated block (11 lines × 2) (eventmesh-storage-plugin/eventmesh-storage-rocketmq5/src/main/java/org/apache/eventmesh/storage/rocketmq5/storage/RocketMQ5RemotingStoragePlugin.java)
• Duplicated block (13 lines × 2) (eventmesh-examples/src/main/java/org/apache/eventmesh/a2a/demo/ce/CloudEventsProvider.java)
• Duplicated block (5 lines × 2) (eventmesh-connector-runtime/src/main/java/org/apache/eventmesh/connector/ConnectorAdminServer.java)
• …and 123 more

• A2AFrameAdaptor.toFrame (cognitive 19) (eventmesh-protocol-plugin/eventmesh-protocol-a2a/src/main/java/org/apache/eventmesh/protocol/a2a/A2AFrameAdaptor.java)
• A2AFrameAdaptor.toFrame (cyclomatic 16) (eventmesh-protocol-plugin/eventmesh-protocol-a2a/src/main/java/org/apache/eventmesh/protocol/a2a/A2AFrameAdaptor.java)
• A2AGatewayHttpHandler.channelRead0 (cognitive 25) (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/a2a/A2AGatewayHttpHandler.java)
• A2AGatewayHttpHandler.channelRead0 (cyclomatic 16) (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/a2a/A2AGatewayHttpHandler.java)
• A2AGatewayHttpHandler.handleList (cognitive 27) (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/a2a/A2AGatewayHttpHandler.java)
• A2AGatewayHttpHandler.handleList (cyclomatic 16) (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/a2a/A2AGatewayHttpHandler.java)
• AgentApplication.main (cognitive 18) (eventmesh-agent-runtime/src/main/java/org/apache/eventmesh/agent/AgentApplication.java)
• Ambiguous naming and parameter overlap. The method subscribe takes a SubscriptionItem but no URL, while subscribe_webhook takes both. It is unclear if subscribe is a legacy method, a simplified wrapper, or if SubscriptionItem internally holds the URL. The naming convention subscribe vs subscribe_webhook suggests a distinction that isn't immediately obvious from the signature alone (e.g., is one for HTTP and one for gRPC?).
• ClassTooLong: CloudEventsClient (eventmesh-sdks/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/cloudevents/CloudEventsClient.java)
• ClassTooLong: EventMeshCloudEventUtils (eventmesh-sdks/eventmesh-sdk-rust/src/common/grpc_eventmesh_message_utils.rs)
• ClassTooLong: RocketMQ5RemotingStoragePlugin (eventmesh-storage-plugin/eventmesh-storage-rocketmq5/src/main/java/org/apache/eventmesh/storage/rocketmq5/storage/RocketMQ5RemotingStoragePlugin.java)
• ClassTooLong: UniHttpServer (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/http/UniHttpServer.java)
• ClassTooLong: UniIngressService (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/ingress/UniIngressService.java)
• CloudEventsClient.subscribeLiteBytes (cognitive 21) (eventmesh-sdks/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/cloudevents/CloudEventsClient.java)
• ConnectorRuntime.runSinkOnce (cognitive 16) (eventmesh-connector-runtime/src/main/java/org/apache/eventmesh/connector/ConnectorRuntime.java)
• ConnectorRuntime.runSourceOnce (cognitive 20) (eventmesh-connector-runtime/src/main/java/org/apache/eventmesh/connector/ConnectorRuntime.java)
• Critical CVE: [GHSA redacted] (eventmesh-sdks/eventmesh-sdk-go/go.mod)
• DefaultStreamingResponse.startReader (cognitive 20) (eventmesh-sdks/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/cloudevents/stream/DefaultStreamingResponse.java)
• Documentation: no project overview (docs/index.md)
• Duplicated block (10 lines × 2) (eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/grpc/common/ClientType.java)
• …and 440 more

• 57 commits — 37 feature/other, 20 fixes

• eventmesh-runtime/src — 29 commits
• (root) — 5 commits
• docs/architecture-review — 3 commits
• docs/feature — 3 commits
• .github/workflows — 2 commits
• docker/Dockerfile — 2 commits
• eventmesh-common/src — 2 commits
• deploy/kubernetes — 1 commit
• docs/architecture — 1 commit
• docs/control-plane.md — 1 commit
• docs/state-store-failure-matrix.md — 1 commit
• eventmesh-agent-runtime/src — 1 commit
• eventmesh-agent/src — 1 commit
• eventmesh-architecture-guard/src — 1 commit
• eventmesh-connector-api/src — 1 commit
• eventmesh-sdks/eventmesh-sdk-java — 1 commit
• eventmesh-storage-plugin/eventmesh-storage-api — 1 commit
• eventmesh-storage-plugin/eventmesh-storage-memory — 1 commit

• fix: Fix broken Quick start README anchors (#5331)
• fix: fix(#5342): storage capability matrix + arch-guard plugin boundary rules (#5348)
• fix: fix(#5350): run containers as non-root, add HEALTHCHECK, drop unused locale setup (#5351)
• fix: fix(#5356): fail fast on PARTITION_OWNED_PULL without shared MetaStore + arch-guard (#5367)
• fix: fix(#5357): make EventMeshFrame immutable (defensive copy + unmodifiable view + withAttribute) (#5368)
• fix: fix(#5357): use immutable frame for MQ offset/partition stamps (#5388)
• fix: fix(#5358): QuotaHandle (AutoCloseable) + gate-scoped QuotaManager access (#5369)
• fix: fix(#5359): wire DeliveryTopology + MetaStore into runtime boot; rollback on failure (#5370)
• fix: fix(#5360): fence stale owners from durable side effects (offsets / broker ACK) (#5371)
• fix: fix(#5361): FrameLimits — enforce wire bounds at encode AND decode (no-alloc rejects) (#5372)
• fix: fix(#5362): classify A2A operations for quota (SUBMIT=BACKLOG, reads=THROUGHPUT) (#5373)
• fix: fix(#5364): admin token guard (fail-closed) + chaos in-process cases (#5374)
• fix: fix(#5376,#5377,#5378): cluster routing, single ownership lifecycle, durable delivery bootstrap (#5383)
• fix: fix(#5379,#5380,#5381,#5382): recovery re-dispatch, honest deployment modes, fail-closed security gate, connector generation fencing (#5385)
• fix: fix(cluster): unify delivery topology with Meta CAS + fencing (#5293 #5288) (#5308)
• fix: fix(connector): complete the 16 incomplete connector implementations (#5394)
• fix: fix(offset): unify MQ physical offset and align pull cursor to ACK offset on restart
• fix: fix(protocol): single protocol path — EventMeshFrame across HTTP ingress, filter chain and TCP egress (#5299) (#5319)
• fix: fix(reliability): atomic offset writes, durable DLQ, epoch delivery IDs (#5289 #5290 #5291 #5292) (#5307)
• fix: fix(state): persist ReliableDispatcher.pending to DeliveryStateStore (issue #5301 Sub-PR B, fixes #5294 #5295) (#5311)
• …and 37 more

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

apache/eventmesh 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.