kubemq-io/kubemq-bridges

KubeMQ Bridges is a message routing and transformation service that connects KubeMQ clusters by bridging, replicating, and transforming data flows between sources and targets. It supports diverse message types including events, commands, queries, and queues, utilizing middleware for retry, rate limiting, and metrics. The system features hot-reloadable configuration, structured logging, and a comprehensive HTTP API for monitoring and management.

24 changes.

This period marks the initial release of KubeMQ Bridges, introducing a comprehensive framework for bridging, replicating, and transforming messages between KubeMQ clusters. The work established the core architecture, including unified source and target connectors for commands, queries, events, and queues, alongside essential middleware for logging, metrics, and rate limiting. The release also included cross-platform support, hot-reloading capabilities, and example applications demonstrating multi-cluster data flows.

5 changes.

This period focused on introducing new utility packages for UUID generation, browser handling, and configuration building. It also enhanced observability by adding specific log files for KubeMQ bridge errors and adapting logging formats for containerized environments.

The API package now exposes an HTTP server (using the Echo framework) that provides several new endpoints: /health and /ready for status checks, /metrics for Prometheus metrics, and /bindings and /bindings/stats to retrieve binding status and statistics. This introduces a new way to interact with the system's binding service via HTTP.

api · high confidence

The \targets/query\ directory now contains a new Query target implementation, including \client.go\ for handling RPC query requests, \options.go\ for configuration parsing, and \client\_test.go\ for testing. This addition enables the bridge to send RPC queries to a KubeMQ cluster, supporting various request types such as events, command, and queue messages. The connector allows users to configure connection details like address, client ID, authentication token, and timeout, facilitating integration with KubeMQ's query functionality.

targets/command, targets/query · high confidence

A new queue target implementation has been added to the KubeMQ Bridges project. This feature allows users to send messages to KubeMQ queues, supporting various message types including events, commands, queries, and event stores. The implementation includes configuration options for address, client ID, authentication token, channels, expiration, delay, max receive count, and dead-letter queue settings. The change introduces the core client logic, options parsing, and corresponding unit tests to verify message parsing and sending functionality.

targets/queue · high confidence

Users can now connect to a Kubemq queue to process messages. The new source supports configuration for address, channel, batch size, and wait timeout, and allows for round-robin load balancing across multiple targets.

sources/queue · high confidence

Added a new example in the \examples/replicate\ directory that demonstrates how to replicate messages from one cluster as source to multiple clusters as targets. The update includes a \main.go\ file that sets up Go clients to send events to a source cluster and subscribe to events from three target clusters, alongside \deploy.yaml\ and \README.md\ files that provide the Kubernetes deployment configuration and usage instructions.

examples/replicate · medium confidence

A new \pkg/uuid\ package has been introduced, providing a \UUID\ type with methods for string conversion, version detection, and equality checks. It includes functions to parse UUIDs from strings or byte slices, generate random version-4 UUIDs, and validate input against a v4 UUID regex pattern.

pkg/uuid · high confidence

Added a new example in the \examples/aggregate\ directory that demonstrates how to aggregate data from multiple clusters as sources and send all events to a single cluster as targets. The example includes a Go application (\main.go\) that connects to four distinct KubeMQ clusters (A, B, C, D) to send and receive events, alongside a \deploy.yaml\ file that configures the KubeMQ clusters and a bridge connector to route events from the three source clusters to the target cluster.

examples/aggregate · medium confidence

A new example in the examples/bridge directory demonstrates how to bridge a query request from one cluster as a source to multiple clusters as targets. The example includes a Go application (main.go) that sends queries to multiple clients (client B, C, and D) and a Kubernetes deployment file (deploy.yaml) that sets up two KubeMQ clusters (cluster-a and cluster-b) along with a KubeMQ Connector of type 'bridges' to handle the bridging logic. A README.md file provides instructions on how to run the example using kubectl.

examples/bridge · high confidence

The codebase now includes a new \pkg/browser\ package that provides helpers to open files, readers, and URLs in a browser window, with platform-specific implementations for Darwin, Linux, OpenBSD, Windows, and a fallback for unsupported systems. Additionally, a new \pkg/builder\ package has been introduced, featuring a \ConnectorConfig\ structure and a \GetBuildManifest\ function that fetches and parses YAML-based connector configurations using the \go-resty\ and \gopkg.in/yaml.v2\ libraries.

pkg/browser, pkg/builder · high confidence

Users can now subscribe to and process commands and queries via the new command and query source connectors. Each connector allows configuring connection details (address, client ID, auth token, channel, group), enabling auto-reconnect, and specifying the number of concurrent subscribers (sources) to handle incoming messages. The implementation includes full configuration parsing, client initialization, and message processing logic for both command and query types.

sources/query · high confidence

Users can now subscribe to KubeMQ events and events-store channels via new source connectors. Each connector supports multiple concurrent subscriptions (configurable via the 'sources' property) and offers an optional round-robin load balancing mode that distributes incoming events across configured targets, rather than broadcasting every event to all targets.

sources/events, sources/events-store · high confidence

The middleware package now includes new middleware components for structured logging, request metrics, rate limiting, and automatic retries. Users can configure log levels, enable metrics reporting, set rate limits, and define retry strategies with configurable delays and jitter. These middleware functions can be chained to apply these behaviors to requests.

middleware · high confidence

Users can now route messages to KubeMQ's Event Store and standard Events using the new \target.events\ and \target.events-store\ connectors. These new targets accept incoming commands, queries, events, and queue messages and forward them to the specified channels, with configuration options for address, client ID, auth token, and channel routing.

targets/events-store · high confidence

Added a new example in the examples/transform directory that demonstrates how to transform and aggregate events from one cluster and replicate them as queue messages to other clusters. The example includes Go code (main.go) that connects to multiple KubeMQ clusters, subscribes to events, and converts them into queue messages. The accompanying Kubernetes deployment manifests (deploy.yaml) and README documentation provide a complete setup for this transformation workflow.

examples/transform · high confidence

A new log file, kubemq-bridges.log, has been added to the events-store to capture KubeMQ bridge errors, such as the 'error received from target' message.

sources/events-store/logs · high confidence

The pkg/metrics package now includes a new Prometheus-based metrics exporter that exposes counters for requests, responses, and errors, each labeled by binding, source kind, and target kind. The implementation registers five Prometheus counters (request count, response count, request volume, response volume, and error count) and provides an HTTP handler to serve the metrics endpoint, allowing users to monitor these specific metrics in their Prometheus dashboards.

pkg/metrics · high confidence

The pkg/ratelimit package now provides a rate limiter that controls the rate of execution, ensuring that calls to Take() block to maintain the specified requests per second. This implementation includes a Clock interface that allows for a mock clock, enabling deterministic testing of time-based behavior. The package also includes benchmarks to evaluate the performance of the atomic and mutex-based implementations under various concurrency levels.

pkg/ratelimit · high confidence

The application now includes a new \pkg/retry\ package that provides a \Do\ function for executing operations with automatic retry capabilities. Users can configure the number of attempts, delay between retries (with support for fixed, exponential backoff, and random delay types), maximum jitter, and conditional retry logic via options like \Attempts\, \Delay\, \MaxDelay\, \DelayType\, and \RetryIf\. The package also supports an \Unrecoverable\ error wrapper to stop retries immediately and a \LastErrorOnly\ option to return only the final error instead of a list of all errors.

pkg/retry · high confidence

A new round-robin load balancer has been introduced in the roundrobin package. This provides a mechanism to distribute requests sequentially across a fixed set of targets, ensuring even distribution of traffic.

pkg/roundrobin · high confidence

This change introduces the initial release of KubeMQ Bridges, a tool for bridging, replicating, and transforming messages between KubeMQ clusters. The release includes a new configuration system that supports hot-reloading of the \config.yaml\ file, allowing users to update binding settings without restarting the application. Additionally, the application now supports running as a Windows service and provides cross-platform binaries for Linux, macOS, and Windows, with automated release builds managed by GoReleaser.

(repo-wide) · high confidence

Users can now define and manage binding configurations that connect data sources to targets. The new binding package introduces a Service that initializes, starts, and stops these bindings, handling middleware chains (retry, rate limiting, metrics) and tracking the status of each binding. This provides a structured way to configure and monitor data pipelines within the bridge application.

binding · high confidence

The logger package has been replaced with a new implementation that uses the Zap library for structured, structured JSON or console logging. The change adds support for automatic log rotation, allowing logs to be written to files that are automatically rotated based on size (defaulting to 100MB) and age (defaulting to 28 days), with optional gzip compression. Additionally, the logger now integrates with the \kardianos/service\ package to write logs to the system service logger when running as a Windows service, ensuring consistent logging behavior across different deployment environments.

pkg/logger · high confidence

Added a new \sources/source.go\ file that defines a \Source\ interface and an \Init\ factory function. This change introduces a centralized way to initialize different source types (command, query, events, events-store, and queue) based on their kind, allowing the application to dynamically select the correct source implementation at runtime.

sources · high confidence

A new log file, logs/kubemq-bridges.log, was added to capture gRPC queue client connection errors and disconnections for the bridge-up and bridge-down sources, providing visibility into upstream and downstream connectivity issues.

logs · high confidence

The application's default configuration now adapts to the deployment environment. In containerized environments, the API port changes to 8080, file logging is disabled, and the logger type switches to JSON format. Non-containerized environments continue to use port 8082, file logging, and console logging.

global · high confidence

The \targets/target.go\ file introduces a new \Target\ interface and a corresponding factory function that instantiates specific target implementations (command, query, events, events-store, and queue) based on a kind string. This change provides a standardized way to initialize and execute different types of message targets within the application, allowing the system to dynamically select and manage various target types through a single abstraction.

targets · high confidence

The application now supports hot-reloading of configuration files. When the configuration file is modified, the system detects the change and automatically reloads the new configuration, allowing updates to bindings, API ports, and log levels without requiring a service restart.

config · high confidence

The vendor directory now includes the xxhash v2 library for high-performance 64-bit hashing, the perks library for computing approximate quantiles over data streams, and the spew library for deep pretty-printing of Go data structures. These additions provide new capabilities for hashing, statistical analysis, and debugging output formatting within the application.

vendor · high confidence

The project's Go module dependencies have been updated, including the core Kubemq client library (kubemq-go) to v1.7.9, the Echo web framework to v4.11.2, and various other packages such as fsnotify, viper, and gRPC. These updates ensure the project uses the latest stable versions of its Go dependencies.

(dependencies) · high confidence

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

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

• Code Health 88 → 94 (+5.6)
• Architecture 100 → 95 (-4.9)
• Maturity 57 → 57 (+0.0)
• Readiness 54 → 65 (+10.5)
• Security 61 → 68 (+6.5)

• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (go.mod)
• Critical CVE: [GHSA redacted] (go.mod)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (sources/command/source.go)
• Duplicated block (10 lines × 2) (sources/events-store/source.go)
• Duplicated block (10 lines × 2) (targets/command/client.go)
• Duplicated block (10 lines × 2) (targets/command/client.go)
• Duplicated block (10 lines × 2) (targets/events-store/client.go)
• Duplicated block (10 lines × 4) (sources/command/source.go)
• Duplicated block (10 lines × 4) (targets/events-store/client.go)
• Duplicated block (10 lines × 4) (targets/events/client.go)
• Duplicated block (11 lines × 2) (sources/command/source.go)
• Duplicated block (12 lines × 2) (sources/command/source.go)
• Duplicated block (12 lines × 3) (examples/bridge/main.go)
• Duplicated block (15 lines × 2) (examples/bridge/main.go)
• Duplicated block (15 lines × 2) (examples/replicate/main.go)
• Duplicated block (17 lines × 2) (examples/aggregate/main.go)
• Duplicated block (8 lines × 15) (examples/aggregate/main.go)
• Duplicated block (9 lines × 2) (targets/command/options.go)
• …and 34 more

• Critical CVE: [GHSA redacted] (go.mod)
• Critical CVE: [GHSA redacted] (go.mod)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 3) (targets/events-store/options.go)
• Duplicated block (10 lines × 4) (examples/aggregate/main.go)
• Duplicated block (10–11 lines × 4) (examples/aggregate/main.go)
• Duplicated block (10–11 lines × 5) (sources/command/options.go)
• Duplicated block (12 lines × 2) (sources/command/source.go)
• Duplicated block (12 lines × 3) (examples/aggregate/main.go)
• Duplicated block (12 lines × 4) (targets/events-store/client.go)
• Duplicated block (12–13 lines × 3) (examples/aggregate/main.go)
• Duplicated block (12–13 lines × 4) (targets/events/client.go)
• Duplicated block (13 lines × 2) (examples/transform/main.go)
• Duplicated block (13 lines × 2) (sources/command/source.go)
• Duplicated block (13 lines × 3) (examples/bridge/main.go)
• Duplicated block (13 lines × 3) (examples/transform/main.go)
• Duplicated block (13 lines × 5) (examples/aggregate/main.go)
• Duplicated block (14 lines × 4) (targets/queue/client.go)
• Duplicated block (14–15 lines × 2) (sources/command/source.go)
• …and 66 more

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

kubemq-io/kubemq-bridges 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.