apache/eventmesh
52.4
Adequate · 9 November 2026
65.8k
lines of production code
Java
with C, Go
10
measurements over time
What this system is
Apache EventMesh is a unified event mesh platform that manages subscriptions and delivery semantics over a message queue acting as a write-ahead log, using CloudEvents as its standard data format. It provides a pluggable connector runtime with source and sink implementations for various systems like Kafka, RocketMQ, and HTTP, alongside an agent gateway that bridges routed prompts to LLMs. The system supports multiple transport protocols including TCP, HTTP, and gRPC, and offers SDKs for Java, Go, C, and Rust to facilitate client integration.
How it got here
2019–2021 — Apache EventMesh rebrand and protocol standardization
40 changes.
The project rebranded from DeFiBus to Apache EventMesh, establishing unified CloudEvents architecture and governance structures. Significant work focused on implementing a new annotation-driven configuration framework, robust SPI-based plugin loading, and comprehensive HTTP and TCP protocol models with codecs. This period also introduced runtime management scripts, architectural guardrails, and extensive example utilities to support the new standardized protocol layer.
2022–2023 — multi-language SDKs and storage abstraction
21 changes.
This period focused on expanding EventMesh's client ecosystem by introducing initial SDKs for Go, Rust, and C, alongside significant enhancements to the Java SDK with gRPC and streaming support. Concurrently, the project established a unified storage plugin architecture with capability-based abstractions and implemented native pull-mode plugins for Kafka and RocketMQ to centralize offset management. Infrastructure improvements included adopting JDK 21 for Docker images and standardizing configuration handling across the codebase.
2024–2026 — Agent protocol and connector architecture
22 changes.
This period focused on introducing the A2A protocol plugin and a dedicated agent runtime to support agent-to-agent communication and LLM integration. It also involved a comprehensive refactoring of the connector ecosystem, establishing a unified configuration model and implementing new source/sink plugins for various systems while hardening the connector runtime against data loss.
Features
A2A Gateway REST and SSE API exposed on the runtime
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
Add A2A Gateway Client Demo for agent interaction
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
Add CloudEvents TCP publish and request-reply examples
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
Add Go SDK TCP protocol header serialization
The Go SDK now includes a TCP header structure with JSON marshaling and unmarshaling logic, enabling the serialization of command, code, description, sequence, and properties fields for TCP-based communication.
github.com/apache/eventmesh/eventmesh-sdk-go · high confidence
Add in-memory storage plugin for local development and testing
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
Add utility helper class for examples
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
Added CloudEvents TCP subscription examples for async and sync modes
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
Added Java gRPC stubs and CloudEvent protocol models
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
Added gRPC AdminService protocol definitions and Java stubs
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
Added gRPC CloudEvent protocol resolver for Java
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
Agent Card JSON validation added to A2A protocol plugin
The A2A protocol plugin now includes an AgentCardValidator that checks incoming Agent Card JSON against the A2A schema (loaded from /a2a/agent\_card\_schema.json). This ensures that agent cards conform to the expected structure before processing, with validation enabled by default but gracefully falling back to basic JSON-object checks if the schema resource is missing or loading fails.
eventmesh-protocol-a2a · high confidence
Expanded configuration type support with new data converters
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
HTTP protocol resolvers for single and batch message sending
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
Initial release of the EventMesh C SDK with TCP support and RMB messaging
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
Introduce A2A (Agent-to-Agent) protocol plugin
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
Introduce EventMesh Agent runtime with HTTP-fetch tool and SPI plugin support
This change adds the EventMesh Agent runtime (eventmesh-agent-runtime), a standalone process that registers with the EventMesh runtime, subscribes to its own lite channel, and bridges routed prompts to an OpenAI-compatible LLM gateway. It includes a new in-memory conversation store with sliding-window history and LRU eviction, a control client for the runtime's /agent/\* endpoints, and a tool registry that supports both connector-backed tools and SPI-deployed custom tools. As the first in-tree plugin, it ships an HttpFetchTool (eventmesh-agent-plugin-http-fetch) that fetches HTTP/HTTPS URLs and returns the truncated body, enabled via the agent.tools.spi system property. The runtime is launched via bin/start-agent.sh, configured through environment variables (e.g., LLM\_BASE\_URL, LLM\_API\_KEY, AGENT\_RUNTIME\_URL), and logs via log4j2.
(repo-wide) · high confidence
Introduce HTTP protocol body abstraction classes
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
Introduce Java SDK gRPC protocol common classes
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
Introduce MeshMessageProtocolAdaptor for unified protocol conversion
The new MeshMessageProtocolAdaptor class provides a central entry point for converting between internal EventMesh protocol objects (TCP, HTTP, and gRPC CloudEvents) and standard CloudEvents. This adaptor handles deserialization from TCP packages and HTTP commands (including batch and sync/async send requests) into CloudEvents, as well as serialization from CloudEvents back into the appropriate protocol-specific structures (HttpCommand, EventMeshMessage, or gRPC wrappers), enabling consistent protocol handling across different transport mechanisms.
eventmesh-protocol-meshmessage · high confidence
Introduce TCP protocol data model classes
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
Introduce initial Go SDK module with core protocol definitions and utilities
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
Introduce initial Rust SDK with gRPC CloudEvents support
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
Introduce legacy HTTP protocol transport objects in eventmesh-common
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
Introduce new SPI extension loading framework
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
Introduce unified MeshStoragePlugin SPI with capability-based storage abstraction
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
Introduce unified TCP protocol codec for EventMesh
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
Introduces HTTP protocol common constants and enums
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
Introduces structured HTTP request and response header classes for client operations
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
Introduction of common exception classes
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
Native pull-mode Kafka storage plugin with manual offset management
The Kafka storage plugin now implements the MeshStoragePlugin SPI in native pull mode, meaning EventMesh manages subscription and distribution semantics directly rather than relying on standard MQ consumer groups. The plugin uses a single Kafka consumer with manual partition assignment and seeking, maintaining its own distribution offsets via an OffsetStore instead of committing offsets to the broker. This ensures EventMesh retains full control over message delivery and recovery, with pull offsets persisted to a configurable file path for restart resilience.
eventmesh-storage-plugin/eventmesh-storage-kafka/src/main · high confidence
New EventMesh runtime start and stop scripts
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
New HTTP message header models for push, reply, and batch send operations
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
New HTTP message protocol body classes for pub/sub operations
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
New HTTP protocol body classes for client heartbeat, registration, and subscription operations
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
New HTTP, JDBC, and Knative connector plugins with source/sink implementations and tests
This change introduces three new connector plugins—HTTP, JDBC, and Knative—each providing both source and sink implementations that bridge EventMesh with external systems. The HTTP connector exposes a configurable webhook endpoint to ingest events as CloudEvents and POSTs outgoing events to a target URL. The JDBC connector polls a database table using a configurable query to emit CloudEvents and writes incoming events to a table via a configurable INSERT statement. The Knative connector similarly listens on a local HTTP endpoint to receive events and forwards outgoing events to a Knative sink URL. Each plugin includes hermetic unit tests verifying the source-to-poll and sink-put contracts, along with YAML configuration examples for both source and sink modes.
(repo-wide) · high confidence
New Java SDK for simplified HTTP/CloudEvents runtime and gRPC client
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
New RocketMQ storage plugins using direct remoting RPC
This location introduces two new storage plugins that communicate with RocketMQ brokers via direct Netty remoting RPC instead of the standard client libraries. The RocketMQ 4.x plugin (RocketMQRemotingStoragePlugin) implements the MeshStoragePlugin SPI with TopicManagement, PartitionAssignment, ExplicitOffsetCommit, and AlignPullOffset capabilities, handling message routing and offset persistence. The RocketMQ 5.x plugin (RocketMQ5RemotingStoragePlugin) adds support for POP-mode consumption with DeferredPopAck and implements LiteTopic capabilities for RocketMQ 5.5 Lite Topic (RIP-83) features. Both plugins register themselves via META-INF service files and include TCK tests to verify their declared capabilities.
eventmesh-storage-plugin/eventmesh-storage-rocketmq · high confidence
New TCP demo examples for async, broadcast, and sync request-reply messaging
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
New TCP demo examples for async, broadcast, and sync subscription modes
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
New TCP example utilities for CloudEvents and message testing
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
New TCP protocol resolver for EventMeshMessage conversion
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
New annotation-driven configuration framework with hot-reload support
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
New common enumerations for protocol, component, and connection types
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
New configuration value conversion framework in eventmesh-common
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
New internal binary wire format and pluggable codec for EventMesh
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
New protocol adapter SPI and enhanced plugin factory
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
New protocol and streaming abstractions for EventMesh
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
New streaming API and CloudEvents TCP client in Java SDK
The Java SDK now includes a new streaming API under the \cloudevents.stream\ package, allowing users to open multi-turn sessions via \client.streaming().openSession()\, send prompts with \session.call()\, and manage session lifecycle. Additionally, a new \CloudEventTCPClient\ implementation has been added to the TCP client layer, providing a unified interface for publishing, subscribing, and handling CloudEvents over TCP.
eventmesh-sdk-java · high confidence
New streaming call demo for single-turn and multi-turn agent interactions
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
New unified connector implementations for File, Kafka, Pulsar, and RocketMQ
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 previous dependency on the \openconnect\ library. The File connectors now handle file I/O with proper resource management to prevent file handle leaks, while the Kafka, Pulsar, and RocketMQ connectors provide native integration with their respective brokers. Unit tests are included to verify the new SPI contracts and basic functionality.
(repo-wide) · high confidence
New-architecture connector implementations for Canal, ChatGPT, and DingTalk
This change completes the new-architecture connector implementations by adding the source and sink plugins for Canal, ChatGPT, and DingTalk. The Canal connector replays binlog-derived CloudEvents into MySQL (sink) and consumes binlog entries from a Canal server (source). The ChatGPT connector exposes an HTTP endpoint to receive prompts and optionally calls the OpenAI API to generate completions (source), and posts event data to a webhook URL (sink). The DingTalk connector receives outgoing robot callbacks via an HTTP endpoint with HMAC signature verification (source) and posts event data to a DingTalk webhook (sink). Unit tests and configuration files are included for each connector.
(repo-wide) · high confidence
Registration of MeshMessage protocol and frame adaptors
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
Architecture
Architectural guardrails and deprecation for eventmesh-common types
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
Internal helper classes moved to dedicated sub-packages in eventmesh-common
The \eventmesh-common\ module has been refactored to partition its internal utilities into specific sub-packages (\internal\, \lifecycle\, \metrics\, and \util\). This change introduces new classes such as \ResetCountDownLatch\ and \ThreadWrapper\ for thread management, \AbstractComponent\ for lifecycle handling, \MetricsConstants\ for OpenTelemetry metric labels, and various utility classes for configuration, JSON parsing, and IP address resolution. These components are now explicitly marked as internal helpers and are restricted from being imported by modules outside of \eventmesh-common\ to enforce better encapsulation.
(repo-wide) · high confidence
Behavioural changes
Architecture guard enforces package boundaries in CI
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
Automated generation of distribution license and notice files
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
Centralized configuration constants for example applications
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
Connector runtime hardening: data-loss prevention and assignment fencing
The connector runtime now protects against data loss and stale assignments. Source and sink processing loops isolate per-event failures: a publish exception or null event in a source batch is logged and skipped without stopping the loop, and a sink ACK exception is handled per-delivery so other events in the batch still succeed. Offset checkpoints are also protected so a store failure does not fail the batch. Additionally, connector assignments are fenced by generation so that a stale start from a superseded assignment is rejected, while equal generations are treated as idempotent and newer generations take over; stopping a connector clears the fence. The default EventMesh runtime URL in the launcher and configuration has changed from port 8080 to 10105.
eventmesh-connector-runtime · high confidence
Introduces unified runtime configuration and logging defaults
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
Mark legacy gRPC protocol package as internal with restricted access
The legacy gRPC protocol types in \org.apache.eventmesh.common.protocol.grpc\ are now explicitly marked as internal. Access to this package is restricted to the Java SDK (\eventmesh-sdk-java\), the MeshMessage protocol plugin (\eventmesh-protocol-meshmessage\), and the runtime gRPC bridge, preventing other modules from depending on these legacy protocol definitions.
eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/grpc · high confidence
New Dockerfiles for EventMesh core and connector runtimes with non-root execution and health checks
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
New direct TCP-to-Frame adaptor for legacy MeshMessage protocol
The MeshMessage protocol plugin now includes a new \MeshMessageFrameAdaptor\ that converts legacy TCP \Package\ messages directly to and from the internal \EventMeshFrame\ architecture, bypassing the previous CloudEvent intermediary. This change enables more efficient handling of existing TCP-based MeshMessage traffic within the new streaming and load-balancing infrastructure, while a new \MeshMessageProtocolConstant\ enum centralizes protocol-specific string constants.
eventmesh-protocol-plugin/eventmesh-protocol-meshmessage/src/main/java/org/apache/eventmesh/protocol/meshmessage · high confidence
Project rebrand to Apache EventMesh with unified CloudEvents architecture documentation
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
Refactored SPI plugin loading with dedicated class loaders and centralized constants
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
Standardized configuration model for EventMesh connectors
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
Test coverage
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 tests for the Kafka storage plugin; 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.
Dependencies
Introduce AgentTool SPI and architecture guard for internal package boundaries
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
Upgrade Gradle wrapper to version 8.7
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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 50 → 52 (+2.7)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 60 → 60 (+0.0)
- Architecture 94 → 94 (-0.1)
- Maturity 49 → 77 (+28.1)
- Readiness 42 → 42 (+0.1)
- Security 57 → 49 (-7.7)
- Performance 78 → 100 (+21.7)
Resolved (41)
- Ambiguous naming and parameter overlap. The subscribe method takes a SubscriptionItem but no URL, while subscribe_webhook takes both. It is unclear if subscribe implies a default webhook behavior or if it is a generic subscribe that requires the URL to be embedded in the SubscriptionItem. The naming subscribe_webhook suggests a specific protocol detail, whereas subscribe is generic, yet the distinction is not clear from the signature alone.
- Edited copy of a member (17 corresponding lines) (eventmesh-common/src/main/java/org/apache/eventmesh/common/wire/MeshMessageFrameCodec.java)
- Edited copy of a member (21 corresponding lines) (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/http/UniHttpServer.java)
- Members sharing a duplicated core (4 members, 50+ identical tokens) (eventmesh-connector-plugin/eventmesh-connector-http/src/main/java/org/apache/eventmesh/connector/http/source/HttpSourceConnector.java)
- Members sharing a duplicated core (4 members, 50+ identical tokens) (eventmesh-sdks/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/grpc/producer/CloudEventProducer.java)
- Members sharing a duplicated core (5 members, 50+ identical tokens) (eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/http/body/client/HeartbeatResponseBody.java)
- Members sharing a duplicated core (5 members, 50+ identical tokens) (eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/http/body/message/PushMessageResponseBody.java)
- Members sharing a duplicated core (5 members, 50+ identical tokens) (eventmesh-examples/src/main/java/org/apache/eventmesh/tcp/demo/sub/cloudevents/AsyncSubscribe.java)
- Members sharing a duplicated core (5 members, 50+ identical tokens) (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/http/UniHttpServer.java)
- Members sharing a duplicated core (5 members, 50+ identical tokens) (eventmesh-sdks/eventmesh-sdk-go/examples/grpc/consumer/asyncsub/main.go)
- Members sharing a duplicated core (8 members, 50+ identical tokens) (eventmesh-connector-plugin/eventmesh-connector-chatgpt/src/main/java/org/apache/eventmesh/connector/chatgpt/sink/ChatgptSinkConnector.java)
- Members sharing a duplicated core (8 members, 50+ identical tokens) (eventmesh-connector-plugin/eventmesh-connector-chatgpt/src/main/java/org/apache/eventmesh/connector/chatgpt/source/ChatgptSourceConnector.java)
- Members sharing a duplicated core (8 members, 50+ identical tokens) (eventmesh-connector-plugin/eventmesh-connector-chatgpt/src/main/java/org/apache/eventmesh/connector/chatgpt/source/ChatgptSourceConnector.java)
- No assertions: getConfigByClassPath (eventmesh-common/src/test/java/org/apache/eventmesh/common/config/ConfigServiceTest.java)
- No assertions: getConfigByConfigPath (eventmesh-common/src/test/java/org/apache/eventmesh/common/config/ConfigServiceTest.java)
- No assertions: getConfigByFilePath (eventmesh-common/src/test/java/org/apache/eventmesh/common/config/ConfigServiceTest.java)
- No assertions: getConfigByRootConfig (eventmesh-common/src/test/java/org/apache/eventmesh/common/config/ConfigServiceTest.java)
- No assertions: inMemoryContract (eventmesh-runtime/src/test/java/org/apache/eventmesh/runtime/offset/OffsetStoreTest.java)
- No assertions: inMemoryContract (eventmesh-runtime/src/test/java/org/apache/eventmesh/runtime/state/DeliveryStateStoreTest.java)
- No assertions: inMemoryMultiClientIndependence (eventmesh-runtime/src/test/java/org/apache/eventmesh/runtime/offset/OffsetMonotonicAndRecoveryTest.java)
- …and 21 more
New (14)
- Edited copy of a member (17 corresponding lines) (eventmesh-common/src/main/java/org/apache/eventmesh/common/wire/MeshMessageFrameCodec.java)
- Edited copy of a member (21 corresponding lines) (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/http/UniHttpServer.java)
- Members sharing a duplicated core (4 members, 50+ identical tokens) (eventmesh-connector-plugin/eventmesh-connector-http/src/main/java/org/apache/eventmesh/connector/http/source/HttpSourceConnector.java)
- Members sharing a duplicated core (4 members, 50+ identical tokens) (eventmesh-sdks/eventmesh-sdk-java/src/main/java/org/apache/eventmesh/client/grpc/producer/CloudEventProducer.java)
- Members sharing a duplicated core (5 members, 50+ identical tokens) (eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/http/body/client/HeartbeatResponseBody.java)
- Members sharing a duplicated core (5 members, 50+ identical tokens) (eventmesh-common/src/main/java/org/apache/eventmesh/common/protocol/http/body/message/PushMessageResponseBody.java)
- Members sharing a duplicated core (5 members, 50+ identical tokens) (eventmesh-examples/src/main/java/org/apache/eventmesh/tcp/demo/sub/cloudevents/AsyncSubscribe.java)
- Members sharing a duplicated core (5 members, 50+ identical tokens) (eventmesh-runtime/src/main/java/org/apache/eventmesh/runtime/http/UniHttpServer.java)
- Members sharing a duplicated core (5 members, 50+ identical tokens) (eventmesh-sdks/eventmesh-sdk-go/examples/grpc/consumer/asyncsub/main.go)
- Members sharing a duplicated core (8 members, 50+ identical tokens) (eventmesh-connector-plugin/eventmesh-connector-chatgpt/src/main/java/org/apache/eventmesh/connector/chatgpt/sink/ChatgptSinkConnector.java)
- Members sharing a duplicated core (8 members, 50+ identical tokens) (eventmesh-connector-plugin/eventmesh-connector-chatgpt/src/main/java/org/apache/eventmesh/connector/chatgpt/source/ChatgptSourceConnector.java)
- Members sharing a duplicated core (8 members, 50+ identical tokens) (eventmesh-connector-plugin/eventmesh-connector-chatgpt/src/main/java/org/apache/eventmesh/connector/chatgpt/source/ChatgptSourceConnector.java)
- Off-boarding risk: anonymized user #1
- Projects may be oversized for their cohesion
Architecture
- Unchanged — 0 containers · 10 contexts · 7 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
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.
About this page
- The score is its most recent published measurement, taken on 9 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 9b3efb7bfc2982c3ea765f6d47edd38ad1fbf117 — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-b921b700395b.