Skip to content
CAI
Software that uses CAICheck a score

apache/iggy

58.0

Adequate · 14 November 2026

758.7k

lines of production code

Rust

with Java

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Apache Pinot connector for ingesting Iggy streams

Introduces a new external connector that enables Apache Pinot to consume data directly from Iggy streams. This change adds the necessary Java components to bridge the two systems, including an \IggyConsumerFactory\ to initialize the connection, an \IggyJsonMessageDecoder\ to parse incoming JSON payloads into Pinot's \GenericRow\ format, and configuration classes (\IggyStreamConfig\) to manage connection details such as host, port, credentials, and stream/topic identifiers. The connector is registered via the standard Pinot SPI service loader and plugin properties, allowing users to configure Pinot tables to read from Iggy sources.

foreign/java/external-processors/iggy-connector-pinot · high confidence

Add C\# SDK examples for basic, getting-started, message envelope, and message headers scenarios

New C\# example applications are provided to demonstrate how to use the Iggy SDK for common messaging patterns. The Basic examples show simple TCP producer and consumer clients with configurable settings. The Getting Started examples provide a quick-start guide for connecting, creating streams/topics, and sending/receiving messages. The Message Envelope example demonstrates serializing and deserializing structured messages (like OrderCreated, OrderConfirmed, OrderRejected) using JSON envelopes. The Message Headers example shows how to attach and read custom headers on messages. Shared helper code handles stream/topic creation and message generation.

examples/csharp · high confidence

Add CLI command to retrieve cluster metadata

A new CLI command has been added to fetch and display cluster metadata. Users can now retrieve information about cluster nodes, including their replica ID, name, IP address, endpoint details (TCP, QUIC, HTTP, WebSocket), role, and status. The output can be presented in either a formatted table or a list format, allowing for easier inspection of the cluster's current state.

_core/cli/src/commands/binary\cluster · high confidence

Add CLI commands for managing consumer groups

The CLI now includes commands to create, delete, and retrieve consumer groups within a stream and topic. Users can create a new consumer group by specifying the stream and topic identifiers, delete an existing group by its ID, and view details of a single group or list all groups for a topic in either table or list format, including member and partition information.

_core/cli/src/commands/binary\_consumer\groups · high confidence

Add CLI commands to retrieve client details and list connected clients

The CLI now includes new commands to inspect active connections. Users can retrieve details for a specific client by ID, which displays the client ID, associated user ID, address, transport protocol, and consumer group information. Additionally, a new command lists all currently connected clients, supporting both table and list output formats to show client ID, user ID, address, transport, and consumer group count.

_core/cli/src/commands/binary\client · high confidence

Add Kafka protocol message generation and verification tool

Introduces a new CLI utility, \kafka-message-gen\, located in \gateways/kafka/tools/kafka-tool\. This tool generates binary Kafka wire protocol messages based on the Kafka 4.1.0 schema and can send them to a live server to verify responses. It supports listing supported API keys, generating \.bin\ files for all or specific API versions, and verifying gateway behavior against a running instance, including handling of expected stub errors for APIs like Produce, Metadata, and CreateTopics.

gateways/kafka/tools/kafka-tool · high confidence

Add data-seeder tool for populating test environments

A new \data-seeder\ utility has been added to \core/tools\ to automatically provision and populate test environments. When executed, it connects to an Iggy instance, creates three streams (\prod\, \test\, \dev\), and populates each with specific topics (\orders\, \users\, \notifications\, \payments\, \deliveries\) configured with varying partition counts. It then generates and sends randomized message batches, including optional user headers with mixed types (strings, booleans, integers), to simulate realistic traffic patterns for development and testing.

core/tools · high confidence

Add high-level consumer API for benchmarking

The benchmarking tool now supports a high-level consumer API alongside the existing low-level implementation. This change introduces a \TypedBenchmarkConsumer\ that allows users to select between high-level and low-level client implementations via a configuration flag, enabling more abstract and potentially easier-to-use benchmarking workflows while maintaining backward compatibility with the previous low-level approach.

core/bench/src/actors/consumer · high confidence

Add high-level consumer client for benchmarking

The benchmark tool now includes a high-level consumer client implementation alongside the existing low-level one. This new client, located in \core/bench/src/actors/consumer/client/high\_level.rs\, utilizes the Iggy SDK's high-level consumer APIs (such as \consumer\_group\ and \IggyConsumer\) to handle message consumption, offset storage, and batch metrics collection. It is exposed via a new \ConsumerClient\ trait in \interface.rs\, allowing users to select between high-level and low-level consumption strategies in their benchmarks. Also in this area: Bounded deferred (long) polling for consumers.

core/bench/src/actors/consumer/client, core/bench/src/actors/producer/client · high confidence

Add producing-consumer benchmark actor with high-level API support

The benchmarking tool now includes a new producing-consumer actor that runs a producer and consumer concurrently within a single benchmark run. This actor supports both low-level and high-level client APIs, allowing users to choose the appropriate level of abstraction via a configuration flag. The implementation includes a typed wrapper to select the client type, a core benchmark runner that handles warmup, rate limiting, and finish conditions, and integration with the existing metrics and reporting infrastructure. Also in this area: Bounded deferred (long) polling for consumers.

_core/bench/src/actors/producing\consumer · high confidence

Added C\# SDK example message models

The C\# SDK examples now include a shared \Messages.cs\ file defining the \Envelope\ class and \ISerializableMessage\ interface, along with concrete record types (\OrderCreated\, \OrderConfirmed\, \OrderRejected\) that demonstrate how to structure and serialize message payloads for the examples.

csharp · high confidence

The iggy-connector-library now includes core classes to support the new Flink processor: IggySourceSplit defines the split structure for reading from Iggy partitions, IggySourceEnumeratorStateSerializer handles checkpointing of the source enumerator state, and new JsonDeserializationSchema and JsonSerializationSchema classes provide Jackson-based serialization and deserialization with optional partition key extraction.

iggy-connector-library · high confidence

Added default self-signed TLS certificates for local development

The core/certs directory now includes pre-generated self-signed certificates (iggy\_ca\_cert.pem, iggy\_cert.pem, and iggy\_key.pem) for the 'localhost' domain. This provides a ready-to-use TLS configuration for local development and testing, ensuring that self-signed certificate generation is consistent and available out-of-the-box without requiring manual setup.

core/certs · high confidence

Added local benchmark runner tool

A new \IggyBenchRunner\ CLI tool is now available in \core/bench/runner\ to automate local performance testing. It allows users to specify a local Iggy repository, a starting git reference, and a commit count; the tool then iterates through those commits, builds the \iggy-bench\ binary, runs the benchmarks, and copies the resulting \performance\_results\ to a user-defined output directory.

core/bench/runner · high confidence

Added moving average processor for time series benchmarks

The benchmarking module now includes a new \TimeSeriesProcessor\ trait and a concrete \MovingAverageProcessor\ implementation within the analytics time-series pipeline. This processor applies a sliding-window moving average to time series data points, caching the window sum for efficiency and rounding results to three decimal places, allowing benchmark reports to smooth out noise in performance metrics.

_core/bench/src/analytics/time\series/processors · high confidence

Apache Iggy server-ng becomes the default server with new CLI and cluster metadata support

The server-ng implementation is now the default Apache Iggy server, replacing the legacy server crate. This change introduces a new command-line interface with \--fresh\ and \--with-default-root-credentials\ flags, an ASCII art startup banner, and a new \GetClusterMetadata\ command that exposes cluster topology and node roles. The server also writes a \current\_config.toml\ file at runtime with bound ports, enriches consumer group join/leave requests with client IDs for replication, and enforces namespace caps to prevent aliasing.

core/server/src · high confidence

Benchmark analytics now include latency distribution charts with log-normal fitting

The benchmark reporting module in \core/bench/src/analytics/metrics\ has been expanded to provide deeper visibility into performance characteristics. Individual and group metrics now compute and expose a latency distribution, which includes a histogram of latency samples and fitted log-normal parameters (mu and sigma). This data enables users to visualize the shape of latency tails in benchmark dashboards, moving beyond simple percentile summaries to understand the full distribution of response times.

core/bench/src/analytics/metrics · high confidence

Benchmark producer now supports high-level API selection

The benchmarking tool's producer actor now allows users to choose between the high-level and low-level Iggy client APIs via a \use\_high\_level\_api\ flag. This is implemented through a new \TypedBenchmarkProducer\ enum that wraps the existing \BenchmarkProducer\ with either \HighLevelProducerClient\ or \LowLevelProducerClient\, enabling direct comparison of performance characteristics between the two API layers.

core/bench/src/actors/producer · high confidence

CLI argument definitions restructured into modular subcommand files

The CLI argument definitions in \core/cli/src/args\ have been reorganized from a single monolithic file into separate modules for each resource (e.g., \client.rs\, \cluster.rs\, \consumer\_group.rs\, \context.rs\, \message.rs\, \partition.rs\, \personal\_access\_token.rs\, \segment.rs\, \session.rs\, \stream.rs\, \system.rs\, \topic.rs\, \user.rs\). This change introduces a unified \ListMode\ enum for consistent table/list output formatting across commands, adds new CLI commands for client management, cluster metadata, consumer groups, contexts, and sessions, and standardizes identifier parsing using \clap\'s \Identifier\ type. The \common.rs\ module now provides shared parsing logic for key-value pairs and list modes, while \mod.rs\ wires these subcommands into the main CLI interface.

core/cli/src/args · high confidence

CLI build configuration and documentation added

The core/cli location now includes a build script (build.rs) that configures compile-time feature flags for keyring support, distinguishing between systems using the D-Bus Secret Service backend (Linux and BSDs) and those with native keyring backends (macOS, Windows, and others). Additionally, a README.md file has been added to document the Apache Iggy CLI, providing installation instructions via Cargo and links to project resources.

core/cli · high confidence

CLI commands for getting and setting consumer offsets

Added new CLI commands to retrieve and update consumer offsets. Users can now fetch the current and stored offset for a specific consumer, consumer group, or external group within a stream, topic, and partition, with results displayed in a table. Additionally, users can manually set the offset for these entities, allowing for precise control over consumption progress.

_core/cli/src/commands/binary\_consumer\offsets · high confidence

CLI commands for managing personal access tokens

The CLI now includes commands to create, delete, and list personal access tokens. Creating a token supports optional expiry and can optionally store the token in the system keyring. Listing tokens displays them in either table or list format, showing the token name and expiry status.

_core/cli/src/commands/binary\_personal\_access\tokens · high confidence

CLI context management commands

The CLI now supports managing multiple connection contexts via new commands: \create\ and \delete\ contexts, \use\ to switch the active context, \show\ to inspect a context's configuration (with sensitive fields like passwords and tokens masked), and \get\ to list all available contexts. These commands allow users to store and switch between different server configurations, credentials, and transport settings without re-authenticating or reconfiguring on every invocation.

_core/cli/src/commands/binary\context · high confidence

Centralized configuration module with structured server settings

The core/configs/src module has been introduced to centralize configuration management, exposing a structured set of server settings including cluster, message bus, metadata, partition, QUIC, server, sharding, TCP, and WebSocket configurations. This change consolidates previously scattered config types into a single crate, providing a unified interface for environment variable mappings and file-based configuration providers, which simplifies how users define and validate server parameters.

core/configs/src · high confidence

Deterministic simulator with CLI harnesses and fault injection

The simulator now includes a deterministic execution engine and CLI tools for testing. A new \simulator-ui\ binary provides a scripted demo of partition operations, client registration, and crash recovery. A \workload-fuzz\ binary drives a seeded, deterministic fuzzer that injects replica crashes, network faults, and WAL limits to validate invariants. The underlying simulator core now features a deterministic single-threaded executor with a virtual clock, an in-memory journal, and a message bus that stages outbound traffic into per-replica outboxes for controlled delivery.

core/simulator/src · high confidence

Introduce Apache Kafka wire protocol gateway for Iggy

A new Kafka gateway (\iggy-gateway-kafka\) is added under \gateways/\, providing a TCP listener on port 9093 that translates the Kafka wire protocol to Iggy. The gateway supports SASL/PLAIN authentication, TLS/mTLS listeners, and consumer group coordination (JoinGroup, Heartbeat, etc.). It bridges Kafka Produce, Fetch, ListOffsets, Metadata, CreateTopics, DeleteTopics, and configuration APIs to the Iggy backend via a configurable bridge, while also mapping Iggy global permissions to Kafka ACLs for \DescribeAcls\. The component includes a Dockerfile, a Docker Compose quick-start configuration, and extensive documentation covering record mapping, authentication, and authorization.

gateways · high confidence

Introduce C++ BDD test harness with Dockerized wire server

Added a new BDD testing infrastructure for the C++ SDK, consisting of a Dockerfile, entrypoint script, and clang-format configuration. This setup builds a C++ wire server using Bazel and runs it alongside a Ruby Cucumber runner in a lightweight container (\~330 MB), allowing feature files to be mounted and executed against the C++ implementation. The entrypoint handles server lifecycle, port readiness checks, and tag-based filtering for specific test scenarios like basic messaging and metadata changes.

bdd/cpp · high confidence

Introduce C++ SDK with Bazel build and VSR integration tests

The C++ SDK is now available in the foreign directory, built via Bazel using the Rust toolchain (rules\_rust) and cxxbridge to generate bindings. The SDK exposes a high-level C++ API (iggy.hpp) for client operations, including user management, consumer groups, and messaging. The build configuration pins Bazel 9.2.0 and Rust 1.98.0, and includes BDD tests that run against the VSR server to validate the client's behavior.

foreign · high confidence

Introduce ConfigEnv derive macro for compile-time environment variable mappings

The \core/configs\_derive\ crate now provides the \\#\[derive(ConfigEnv)\]\ macro, which generates type-safe environment variable mappings for configuration structs at compile time. This eliminates runtime ambiguity by producing compile-time constants for valid environment variable names and a builder API for tests. The macro supports nested structs, \Vec\ fields with indexed expansion (up to 256 elements by default), and internally-tagged enums via a \tag\ attribute. Users can control mapping behavior with field attributes such as \skip\, \secret\, \leaf\, and \max\_elements\, ensuring that configuration overrides are strictly typed and discoverable.

_core/configs\derive · high confidence

Introduce Iggy Bench CLI and Dashboard with brand-aligned UI

Users can now run benchmarks via the new \iggy-bench\ CLI tool and visualize results in a modern web dashboard. The CLI supports multiple benchmark types (producer, consumer, combined, consumer group) and transports (TCP, WebSocket), with configurable topic durability policies and host-preparation guidance for accurate measurements. The dashboard provides interactive trend visualizations, hardware/version filtering, and a responsive interface built with a Rust backend and Yew frontend, featuring a redesigned dark mode that applies the Iggy brand colors.

core/bench · high confidence

Introduce Iggy MCP Server with HTTP/stdio transports and TLS support

The Iggy Model Context Protocol (MCP) server is now available in core/ai/mcp/src, enabling AI agents to interact with the Iggy streaming platform. The server supports both HTTP and stdio transports; the HTTP mode allows binding to a configurable address and path, with optional TLS encryption via certificate files and CORS configuration. It connects to Iggy using either username/password or a token (which can be read from a file prefixed with 'file:'), and supports Iggy-side TLS. Telemetry (logs and traces) can be enabled via OpenTelemetry OTLP (gRPC or HTTP). On Unix systems, the server handles SIGINT/SIGTERM for graceful shutdown, and when the 'systemd' feature is enabled, it integrates with systemd's watchdog and readiness notifications.

core/ai/mcp/src · high confidence

This change adds the core library components for a new Apache Flink connector, enabling users to read from and write to Iggy streams. It introduces configuration classes for connection details (IggyConnectionConfig), offset management strategies (OffsetConfig), and TCP endpoint parsing (TcpEndpoint), alongside a custom exception hierarchy (ConnectorException). The library provides an IggySink for writing records with configurable batching, flushing, and partitioning strategies, and an IggySource for reading messages using consumer groups with automatic offset tracking.

foreign/java/external-processors/iggy-connector-flink/iggy-connector-library · high confidence

Introduce QUIC transport client for Iggy

The SDK now includes a new QUIC-based client implementation located in core/sdk/src/quic. This addition provides a high-performance transport layer alongside the existing TCP client, featuring leader-aware connection routing, automatic failover to surviving nodes when the current one dies, and support for consumer groups. The implementation includes a mechanism to skip server certificate verification for development scenarios and handles transient errors with specific retry intervals and roster walking to ensure reliable message delivery.

core/sdk/src/quic · high confidence

Introduce VSR consensus core with view-change, client dedup, and state transfer

The \core/consensus\ module now implements the VSR (View-Stable Replication) consensus protocol, providing the foundational logic for cluster coordination. This includes a \ClientTable\ that manages session lifecycles, request deduplication, and reply caching to ensure at-most-once delivery semantics. The module introduces a \DoViewChange\ (DVC) merge mechanism to safely transition between views, ensuring committed operations are preserved and uncommitted ones are discarded based on quorum evidence. Additionally, it provides state transfer capabilities for bootstrapping new replicas and a \Clock\ abstraction to support deterministic simulation and testing.

core/consensus · high confidence

Introduce cluster metadata and node type definitions

The \core/common/src/types/cluster\ module now exposes structured types for cluster introspection, including \ClusterMetadata\ (holding the cluster name and a list of nodes), \ClusterNode\ (containing name, IP, role, status, and transport endpoints), and supporting enums for \ClusterNodeRole\ (Leader, Follower) and \ClusterNodeStatus\ (Healthy, Starting, Stopping, Unreachable, Maintenance, Unknown). A new \TransportEndpoints\ struct standardizes port definitions for TCP, QUIC, HTTP, and WebSocket connections per node. These types provide the foundational data structures for retrieving and displaying cluster topology and node health information.

core/common/src/types/cluster · high confidence

Introduce core/server module with Docker, config, and build infrastructure

The server component is now a distinct module under core/server, providing the foundational build and deployment artifacts. This includes a Dockerfile and .dockerignore for containerized builds (supporting Rust 1.98, Alpine 3.23, and cross-compilation via zigbuild), a build script (build.rs) that embeds the Web UI and handles musl linking stubs, and a comprehensive config.toml defining HTTP, JWT, and consumer group settings. Additionally, a README.md documents the server's architecture (io\_uring, VSR), configuration, and systemd integration, while a server.http file provides a reference for API endpoints.

core/server · high confidence

Introduce parallelized benchmark report builder with cluster topology support

The benchmarking tool now generates reports using a new analytics module that records cluster topology and parallelizes the report-building process. The \BenchmarkReportBuilder\ fetches cluster metadata from the server to distinguish between single-node and multi-node runs, ensuring that trend data is grouped correctly in the dashboard. Metric aggregation (throughput, latency) is now executed in parallel threads, and the resulting reports include detailed cluster node information alongside standard performance metrics.

core/bench/src/analytics · high confidence

Introduce the \`shard\` crate for multi-shard connection coordination and routing

The new \core/shard\ crate provides the infrastructure for a multi-shard server architecture. It introduces the \IggyShard\ component, which handles frame routing between shards and internal planes, and a \ShardZeroCoordinator\ that manages round-robin delegation of incoming client and replica connections to other shards. The crate also implements a \ShardHost\ trait, allowing the embedding server to handle business logic (such as client requests and metadata submissions) dispatched from the shard layer, and adds comprehensive metrics for tracking inter-shard frame drops.

core/shard · high confidence

Introduce unified Helm chart for Apache Iggy with cluster mode support

The \helm/charts/iggy\ directory now contains a complete, unified Helm chart (version 0.6.0, app version 0.9.0-edge.6) for deploying the Iggy server and web UI. This chart introduces native support for cluster mode, allowing users to deploy a replicated cluster by creating one Helm release per node with a shared roster configuration. It includes validation logic to prevent common misconfigurations (such as wildcard binds or missing replica IDs) at render time, handles \io\_uring\ requirements via specific security contexts, and provides examples for multi-node setups. The chart also standardizes the deployment of server secrets, root user credentials, and ingress resources for both the server and UI components.

helm/charts/iggy · high confidence

Introduces async-aware read-write lock abstraction

The core/common/locking module now provides an async-compatible read-write lock wrapper (IggyTokioRwLock) built on top of Tokio's RwLock. This change introduces a new trait (IggyRwLockFn) and implementation that allows code to perform async read and write operations on shared data, replacing or supplementing previous synchronous locking mechanisms in this location.

core/common/src/locking · high confidence

Introduces durable metadata persistence with snapshot and WAL recovery

The metadata module now persists its state to disk using a combination of snapshots and a Write-Ahead Log (WAL). On startup, the system recovers the last known state by loading the latest snapshot and replaying subsequent journal entries, ensuring no committed operations are lost after a restart. The implementation includes robust error handling for corrupted or mismatched superblock records, preventing the node from booting with inconsistent consensus state. Also in this area: New metadata state machine with deterministic snapshots and RBAC-gated operations.

core/metadata · high confidence

Introduces stream builder module for constructing Iggy clients, producers, and consumers

The \core/sdk/src/stream\_builder/build\ module has been added to provide dedicated builder functions for initializing Iggy SDK components. This includes \build\_iggy\_client\ for establishing connections, \build\_iggy\_consumer\ for configuring and initializing consumers (supporting individual and group modes with options like auto-commit, polling strategies, and prefetching), \build\_iggy\_producer\ for setting up producers with direct configuration, batch lengths, and partitioning, and \build\_iggy\_stream\_topic\_if\_not\_exists\ for automatically creating streams and topics if they do not already exist based on configuration flags. These functions centralize the initialization logic for these core resources.

_core/sdk/src/stream\builder/build · high confidence

Java SDK introduces async TCP client with cluster-aware leader redirection

The Java SDK now provides a new non-blocking TCP client built on Netty, replacing the previous synchronous implementation. This client supports TLS encryption, configurable connection and request timeouts, and connection pooling. In clustered environments, it automatically detects the current leader and redirects requests if the connected node is not the primary, ensuring writes and polls reach the correct partition owner. It also maintains local routing state for consumer groups and partition counts to optimize polling and offset storage. Also in this area: Add support for bounded deferred (long) polling; Send raw commands to a specific cluster replica; Java SDK migration to Apache Iggy with fluent builder API.

java-sdk · high confidence

Java SDK migration to Apache Iggy with fluent builder API

The Java SDK has been migrated to the Apache Iggy project, introducing a new fluent builder API for creating both blocking and async TCP clients as well as HTTP clients. The SDK now requires Java 17, enforces non-null API contracts via a custom annotation, and provides detailed version information including build time and Git commit hash. The new architecture separates client implementations into distinct async and blocking packages, with comprehensive interfaces for streams, topics, messages, consumer groups, and system operations.

foreign/java/java-sdk · high confidence

Java benchmark reporting and CLI data models

The Java benchmark tool now includes a comprehensive set of data models to support structured command-line argument validation, resource provisioning, and detailed performance reporting. This change introduces CLI argument records (GlobalCliArgs, PinnedProducerCliArgs) with built-in validation for credentials, message settings, and timing parameters. It also adds models for provisioned resources (ProvisionedResources) and a full reporting suite (FinalReport, GroupMetrics, IndividualMetrics, LatencyDistribution, TimeSeries, etc.) that captures server stats, hardware context, and granular latency/throughput metrics, enabling users to run benchmarks with validated inputs and receive detailed, structured performance reports.

bench · high confidence

Kafka gateway introduces SASL/PLAIN authentication and TLS support

The Kafka gateway now supports SASL/PLAIN authentication, forwarding Kafka client credentials to the underlying Iggy server for verification, and includes configurable TLS settings for the connection to Iggy. This allows users to secure the gateway with standard Kafka authentication mechanisms and encrypted transport, with configuration managed via environment variables such as \IGGY\_KAFKA\_IGGY\_TLS\_ENABLED\ and \IGGY\_KAFKA\_IGGY\_PASSWORD\.

gateways/kafka · high confidence

Migrate web UI to SvelteKit with new build and deployment tooling

The web interface has been migrated to SvelteKit, introducing a new build pipeline, Dockerfile, and development configuration. This change adds a \justfile\ for simplified local development, a \docker-compose.yml\ for running the server and UI together, and a \Dockerfile\ that builds the SvelteKit app and bundles third-party license compliance files. The UI now uses Tailwind CSS for styling, \@floating-ui/dom\ for positioning tooltips, and the \uuid\ npm library for generating identifiers. API interactions are standardized through a typed schema (\ApiSchema.ts\) and client libraries that handle authentication, error redirection, and safe parsing of large integers (BigInt) to strings.

web · high confidence

New CI scripts for version management, artifact safety, and pre-commit validation

This change introduces a suite of new shell and Node.js scripts under scripts/ci/ to standardize and harden the development workflow. The bump-version.sh script provides a unified tool for managing version numbers across Rust crates, SDKs, and the web UI, supporting patch/minor/major bumps and edge-tagging. Safety and compliance are improved with binary-artifacts.sh (detecting compiled binaries in the repo), license-headers.sh (enforcing Apache headers via HawkEye), and render-node-licenses.mjs (validating npm license compliance). Additionally, apt-install.sh prevents CI jobs from hanging on dead mirrors, while coverage-baseline-affected.sh and edge-affected-images.sh optimize CI runs by only triggering jobs for changed code surfaces. The lib/init.sh script enforces a minimum Bash version (4.2) to ensure script portability.

scripts · high confidence

New CLI commands for managing binary partitions and segments

The CLI now includes commands to create and delete binary partitions, as well as delete binary segments. Users can specify stream, topic, and partition identifiers to manage these binary storage units directly from the command line, with the partition commands supporting count-based creation/deletion and segment deletion supporting count-based removal within a specific partition.

_core/cli/src/commands/binary\_partitions, core/cli/src/commands/binary\segments, core/cli/src/commands/utils · high confidence

New CLI commands for managing streams and topics

The CLI now includes a new set of commands under the \binary\_streams\ and \binary\_topics\ modules to manage resources. Users can create, delete, get, and update streams and topics. The \get\ commands display detailed information in table or list formats, including stream encryption sources and topic partitions, compression, and message expiry settings. The \create\ and \update\ commands support configuring options like compression algorithms, message expiry, max topic size, and custom key-value options.

_core/cli/src/commands/binary\topics · high confidence

New CLI commands for user management

The CLI now includes a new set of commands for managing users, located in the \binary\_users\ module. Users can create, delete, and retrieve individual or list views of users (with table or list output formats). It is also possible to update a user's name or status, change a user's password (with TTY-secure prompting or stdin fallback), and update permissions. These commands interact with the underlying client to perform the respective user lifecycle operations.

_core/cli/src/commands/binary\users · high confidence

New CPU allocation configuration types and allowed-CPUs detection

The \core/cpu\_allocation\ crate now provides the configuration types (\CpuAllocation\, \NumaConfig\) and the \allowed\_cpus\ probe that the server uses to determine which CPU cores are available. The \allowed\_cpus\ function respects environment-imposed restrictions (such as systemd \AllowedCPUs\ or container cpusets) by querying the process's affinity mask, falling back to available parallelism if the mask is unavailable. The new \CpuAllocation\ enum supports parsing from TOML strings for \all\, specific counts, ranges (e.g., \2..8\), and NUMA-aware configurations (e.g., \numa:auto\ or \numa:nodes=0,1;cores=4;no\_ht=true\), enabling the server to correctly pin shards to cores within the allowed set.

_core/cpu\allocation · high confidence

New HTTP API command structures for core resources

The HTTP API layer now includes the request payload definitions for managing streams, topics, partitions, segments, consumer groups, consumer offsets, messages, personal access tokens, and system snapshots. This introduces the structured data models (including extensible key-value options and message polling/sending commands) that enable these operations over HTTP.

core/common/src/http · high confidence

New Java SDK examples for async, blocking, and advanced messaging patterns

Added a suite of Java example applications in the \examples/java\ directory to demonstrate core and advanced usage of the Iggy client. The new examples include \GettingStartedProducer\ and \GettingStartedConsumer\ for basic blocking TCP operations, \AsyncProducer\ and \AsyncConsumer\ for non-blocking async patterns with backpressure and error handling, \MessageHeadersProducer\ and \MessageHeadersConsumer\ for sending and reading custom message headers, \MessageEnvelopeProducer\ and \MessageEnvelopeConsumer\ for structured JSON payload serialization, and \MultiTenantConsumer\ for demonstrating multi-tenant isolation and permissions. Also in this area: Bounded deferred (long) polling for consumers.

examples/java/src/main/java/org/apache/iggy/examples/async · high confidence

New Java benchmark CLI for pinned producer workloads

The \foreign/java/bench\ directory now includes a complete Java-based benchmarking tool, starting with a \pinned-producer\ subcommand. This CLI (powered by picocli) allows users to configure and run asynchronous TCP producer benchmarks against an Iggy server, handling resource provisioning (creating streams and topics), executing the load with configurable message sizes and batch counts, and generating detailed JSON reports with latency and throughput metrics.

foreign/java/bench · high confidence

New Node.js examples for basic, getting-started, and advanced messaging patterns

Added a comprehensive set of TypeScript examples for the Node.js SDK, including basic producer/consumer scripts, a getting-started guide, and advanced patterns such as message envelopes, message headers, multi-tenant streaming, and sink data production. These examples demonstrate how to connect via TCP, handle authentication, manage streams and topics, and process messages with various strategies.

examples/node · high confidence

New Python SDK examples for basic, high-level, and getting-started workflows

The Python SDK documentation now includes comprehensive example scripts demonstrating core usage patterns. The 'basic' examples show low-level stream/topic management and message production/consumption. The 'getting-started' examples provide a complete setup with TCP, TLS, and authentication configuration. The 'high-level' examples introduce the new producer and consumer group APIs, including background producers with sharding and direct producers with partitioning strategies. Additionally, 'message-headers' examples demonstrate how to attach and read custom headers on messages.

python · high confidence

New Rust SDK TCP client with leader-aware failover and TLS support

The Rust SDK now includes a new TCP client implementation in \core/sdk/src/tcp\ that provides robust connection management. This client automatically fails over to a surviving cluster node when the current one dies, using a leader-aware connect mechanism to maintain stability. It also adds support for TLS connections via \rustls\ and includes a \NoServerVerification\ mode for development or testing environments.

core/sdk/src/tcp · high confidence

New Rust SDK examples for basic usage, message headers, and compression

The Rust examples directory now includes comprehensive sample applications demonstrating core SDK patterns. New examples cover basic producer/consumer workflows, message header usage for type-based routing and manual Lz4 compression, and JSON envelope patterns for polymorphic message handling. These samples illustrate how to configure transports, manage authentication, and utilize user-defined headers for metadata and compression signaling.

examples/rust · high confidence

New WebSocket client configuration module

A new configuration module has been added to the common crate to manage WebSocket client settings. This introduces a builder pattern for configuring the server address, auto-login, reconnection behavior (including retries and intervals), and heartbeat intervals. It also exposes fine-grained control over the underlying tungstenite library, allowing users to adjust read/write buffer sizes, maximum message and frame sizes, and TLS options such as domain, CA file path, and certificate validation.

_core/common/src/types/configuration/websocket\config · high confidence

New benchmark analytics and reporting pipeline

The \iggy-bench\ tool now includes a comprehensive analytics and reporting system. It calculates time-series data for latency and throughput (in MB/s and messages/s) using configurable bucket sizes, and generates HTML plots for throughput, latency, and latency distribution (with log-normal fit) that can be saved to a directory and optionally opened in a browser. The benchmark runner now automatically collects system hardware information, generates a JSON report, and saves server logs alongside the results.

core/bench/src · high confidence

New benchmark dashboard server with API and embeddable chart support

The IggyBench Dashboard server is now available in the monorepo, providing a web interface and REST API to browse benchmark results. Users can query hardware configurations, git refs, and specific benchmark reports via endpoints like /api/hardware and /api/benchmark/full/{unique\_id}. The server includes a 'Recent' tab for quick access to recent benchmarks, supports deep linking, and offers embeddable chart endpoints that render charts as PNG images for external use. It also features a GitHub artifact poller to automatically fetch new benchmark data, configurable via command-line arguments for host, port, results directory, and CORS origins.

core/bench/dashboard/server/src · high confidence

New benchmark plotting module for throughput and latency charts

The benchmark reporting system now includes a new plotting module that generates interactive charts for throughput and latency metrics. This addition introduces support for visualizing performance data with configurable axes (time or category), dual Y-axes for combined metrics, and interactive features like tooltips, legends, and data zooming. The module supports both light and dark themes and provides a structured way to render benchmark results as charts.

core/bench/report/src/plotting · high confidence

New benchmark report data types and serialization logic

The benchmark report module now defines a comprehensive set of data structures for serializing and deserializing benchmark results. This includes the root \BenchmarkReport\ model, which aggregates hardware details, server stats, cluster topology, and per-actor/group metrics. New types support detailed metric tracking, including \BenchmarkGroupMetrics\ and \BenchmarkIndividualMetrics\ with custom deserializers that backfill missing latency statistics from time-series data for backward compatibility. The schema also introduces \LatencyDistribution\ for log-normal fit data, \BenchmarkClusterInfo\ for multi-node topology, and \BenchmarkHardware\ for system specs. Additionally, \BenchmarkNumericParameter\ allows benchmark arguments to be specified as either fixed values or ranges, and \TimeSeries\ includes LTTB downsampling logic to optimize chart rendering performance.

core/bench/report/src/types · high confidence

New benchmark report module with downsampled charts and pretty table output

The benchmark reporting system now includes a new \core/bench/report\ module that generates visual charts and formatted text summaries. Time-series charts for throughput and latency use LTTB downsampling to reduce data points while preserving visual shape, ensuring readable graphs even with high-frequency data. A new latency distribution chart displays density, PDF, and percentile curves for each actor group. Additionally, the text-based summary output has been enhanced with a 'pretty' mode that uses colored, wide/narrow terminal-aware tables to display detailed metrics like throughput, latency percentiles, and standard deviation.

core/bench/report/src · high confidence

New benchmark workload profiles and CLI argument definitions

The benchmark CLI now supports additional workload profiles—balanced, end-to-end, and pinned—each with dedicated argument structures for producers, consumers, and consumer groups. Users can configure stream, partition, producer, and consumer counts, as well as topic size limits and message expiry times. The balanced and pinned producer-consumer profiles introduce a configurable read-amplification multiplier (default 1.05) to adjust consumer throughput relative to producers, helping prevent queue buildup during end-to-end latency measurements. Validation rules ensure logical consistency, such as requiring consumer groups to be at least equal to the number of streams in balanced consumer group scenarios, and enforcing a single partition for pinned producer-consumer workloads.

core/bench/src/args/kinds · high confidence

New binary protocol primitives for consumer offsets, metadata changes, and partition fencing

The binary protocol layer now includes new wire primitives that enable finer-grained consumer offset management, real-time metadata change tracking, and strict partition ownership fencing. Consumers can now specify acknowledgement levels (NoAck or Quorum) for offset writes, allowing a fast local path for single-replica partitions while ensuring durability via consensus for replicated ones. The protocol also introduces a comprehensive metadata change log, allowing clients to subscribe to and follow changes to streams, topics, partitions, consumer groups, users, and sessions without needing to re-list resources. Additionally, partition operations now carry context (incarnation, owner generation, metadata op) to fence stale requests and prevent offset state corruption during rebalances or failures.

_core/binary\protocol/src/primitives · high confidence

New binary protocol request types for consumer groups, offsets, and partition routing

The binary protocol crate now includes wire-format definitions and serialization logic for new request types: consumer group management (create, delete, get, join, leave, sync), consumer offset operations (store, get, delete) with explicit AckLevel support, and partition route lookups. These additions enable clients to manage consumer group membership, track and store offsets with quorum or local acknowledgment semantics, and discover partition primaries via the new routing request.

_core/binary\protocol/src/requests · high confidence

New binary protocol response types for message operations

The binary protocol now defines the wire formats and encoders/decoders for four new response messages: PartitionRouteResponse (replying to partition routing requests with incarnation, view, and primary replica details), PollMessagesResponse (delivering polled message batches with headers and iterators), SendMessagesResponse (confirming writes with stream, topic, partition, and base offset details), and WaitForMessagesResponse (listing partitions ready with messages). These types establish the server-side response structures for partition routing, message polling, send confirmations, and readiness waits.

_core/binary\protocol/src/responses/messages · high confidence

New binary protocol response types for topic operations

The binary protocol module now includes explicit response types for topic management commands. \CreateTopicResponse\ is defined as an alias for \GetTopicResponse\, allowing SDKs to reuse a single decoder for both operations. \DeleteTopicResponse\ is defined as an alias for \EmptyResponse\. New structs \GetTopicResponse\ and \GetTopicsResponse\ define the wire format for retrieving topic details and listing topics, including fixed-size partition records and count-prefixed topic headers, with corresponding round-trip and truncation tests.

_core/binary\protocol/src/responses/topics · high confidence

New binary protocol response types for user management and authentication

The binary protocol now includes structured response definitions for user operations, enabling clients to correctly parse server replies. This adds wire-format encoders and decoders for user details (including optional permissions), user lists, and authentication flows (login, combined login/register, and logout). It also defines response types for administrative actions like creating, updating, and deleting users, as well as changing passwords and updating permissions.

_core/binary\protocol/src/responses/users · high confidence

New binary protocol responses for system operations

The binary protocol now includes wire-format encoders and decoders for several system-level responses, enabling clients to interact with core cluster capabilities. This adds support for describing resource options (DescribeOptions), retrieving cluster metadata and node details (GetClusterMetadata), identifying the authenticated client (GetMe), fetching diagnostic snapshots (GetSnapshot), and querying server statistics including cache metrics and file descriptor limits (GetStats). It also introduces paginated metadata change tracking (GetMetadataChanges) to allow clients to follow updates without full re-listing, and defines the response structures for updating resources (UpdateResource) and basic connectivity checks (Ping).

_core/binary\protocol/src/responses/system · high confidence

New binary wire protocol crate with sans-IO codec and batch framing

The \core/binary\_protocol\ crate now serves as the single source of truth for the Iggy binary wire format, replacing the previous \ServerCommand\/\BytesSerializable\ approach. It introduces a sans-IO codec (\WireEncode\/\WireDecode\) and defines the exact request/response frame layouts (\\[length\]\[code\]\[request\_id\]\[payload\]\ and \\[status\]\[length\]\[request\_id\]\[payload\]\). The crate also introduces a new 256-byte batch header structure for message ingestion and replication, a command dispatch table mapping codes to VSR consensus operations, and a packed namespace layout for routing. This change standardizes the wire format shared between the server and SDK, enabling zero-copy parsing and stricter validation of batch checksums and frame lengths.

_core/binary\protocol/src · high confidence

New binary-system CLI commands for session management, diagnostics, and metadata

The CLI now includes a suite of new commands under the binary-system module: login and logout manage server sessions and personal access tokens via the OS keyring; session status and me display current authentication and client details; ping measures server latency; stats reports server resource usage (CPU, memory, disk, threads) in table, list, JSON, or TOML formats; snapshot exports system diagnostics; options lists available server configuration keys; and metadata changes allows following or querying metadata updates. These commands provide users with direct, interactive ways to manage sessions, monitor server health, and observe system state from the command line.

_core/cli/src/commands/binary\system · high confidence

New centralized CLI argument definitions for client transports

A new \ArgsOptional\ struct has been introduced in \core/common/src/types/args/mod.rs\ to define command-line arguments for client configuration. This change adds support for configuring transport protocols including HTTP, TCP, and QUIC, allowing users to specify connection details such as API URLs, server addresses, and TLS settings. It also introduces options for managing credentials, encryption keys, and retry/reconnection behaviors specific to each transport type, enabling more granular control over client connectivity and security.

core/common/src/types/args · high confidence

New centralized configuration module for server, HTTP, and system settings

A new \core/configs/src/common\ module has been introduced to centralize and standardize server configuration. This change adds structured configuration types for HTTP (including CORS, JWT, metrics, and TLS), system settings (logging, encryption, and runtime paths), and server internals (heartbeat, consumer groups, memory pool, and data maintenance). It includes default value resolution from the static \server/config.toml\, validation logic to enforce constraints (such as JWT algorithm restrictions to HMAC, encryption key formats, and logging retention limits), and secure handling of secrets (ensuring encryption keys and JWT secrets are never serialized into runtime snapshots or logs).

core/configs/src/common · high confidence

New client-side consumer group state management and personal access token handling in common library

The \core/common\ library now includes \ConsumerGroupClientState\ to manage client-side caching of consumer group assignments, partition counts, and round-robin cursors for the VSR transport, enabling local partition resolution and rebalance detection via generation fences. It also introduces \PersonalAccessToken\ with secure random token generation and hashing, and exposes \ClientState\ for tracking connection lifecycle. These changes support improved consumer group coordination and secure token management within the SDK.

core/common/src · high confidence

New common traits for binary transport, client lifecycle, and module-specific operations

The \core/common/src/traits\ module now exposes a comprehensive set of Rust traits that define the client-side API for interacting with the Iggy server. \BinaryTransport\ provides the low-level wire protocol methods, including raw message sending, partition-aware routing, and deferred polling support. \Client\ unifies the high-level lifecycle management (connect, disconnect, shutdown) and introduces operation resolution and abandonment for handling uncertain write outcomes. Module-specific traits (\MessageClient\, \ConsumerGroupClient\, \ConsumerOffsetClient\, \PartitionClient\, \StreamClient\, \TopicClient\, \SystemClient\, etc.) define the standard CRUD and operational commands for each resource, with detailed documentation on authentication requirements, error codes, and partition context handling. \BinaryAuth\ adds a helper to enforce authentication state before operations, and \Partitioner\ allows custom partition ID calculation logic.

core/common/src/traits · high confidence

New common utility modules for byte sizes, durations, and encryption

The \core/common/src/utils\ module now includes new types and helpers to improve configuration handling and data security. \IggyByteSize\ and \MaxTopicSize\ allow users to define and parse human-readable storage limits (e.g., "1 GB") for topics. \IggyDuration\ and \IggyExpiry\ provide standardized, human-readable time parsing for message retention and expiration. Additionally, \crypto.rs\ introduces AES-256-GCM encryption for message payloads and headers, while \checksum.rs\ and \hash.rs\ provide xxHash and Blake3 utilities for data integrity.

core/common/src/utils · high confidence

New configuration types for connection strings and auto-login credentials

The \auth\_config\ module now includes new types to support parsing connection strings and managing auto-login credentials. Users can now configure authentication via \AutoLogin\ (enabling or disabling automatic login with \Credentials\ such as username/password or personal access tokens) and parse connection strings using \ConnectionString\ and \ConnectionStringUtils\. The \Credentials\ type wraps sensitive data in \SecretString\ to prevent accidental leaks, and \ConnectionStringOptions\ provides a trait for parsing connection-specific parameters like retries and heartbeat intervals.

_core/common/src/types/configuration/auth\config · high confidence

New declarative integration test harness with transport and config matrix generation

The integration test infrastructure has been replaced with a new \\#\[iggy\_harness\]\ procedural macro that generates test variants automatically. Tests can now declare a matrix of client transports (TCP, HTTP, QUIC, WebSocket, and their TLS variants) and server configuration overrides (such as heartbeat intervals or checksum validation) using a declarative DSL. The harness also supports multi-node cluster testing, automatic TLS certificate generation, and fixture injection, significantly reducing boilerplate and enabling broader coverage of transport and configuration combinations. Also in this area: Added tests for multi-link replica connections and backpressure tracking; Sinks now use long-polling with \max\_wait\ and \min\_count\ instead of \poll\_interval\; Added integration test for slow replica rejoin under sustained writes; Added integration tests for raw replica requests and SDK client wrapper.

core/integration, core/integration/src/harness/orchestrator · high confidence

New integration test harness for managing server and client processes

The integration test infrastructure now includes a new \harness/handle\ module that provides structured handles for managing test binaries. This adds \ServerHandle\ to launch and monitor the Iggy server (including TLS and cluster readiness checks), \ClientHandle\ and \ClientBuilder\ to connect via TCP, QUIC, HTTP, or WebSocket with optional auto-login, and dedicated handles for the \iggy-connectors\ and \iggy-mcp\ services. These components centralize process lifecycle, log collection, and health checks to make integration tests more robust and easier to write.

core/integration/src/harness/handle · high confidence

New sharded connection cache and multi-transport client listeners

The message bus now includes a sharded connection cache with a round-robin allocation strategy to distribute SDK client connections across shards, alongside dedicated listener modules for TCP, TCP-TLS, WebSocket, WSS, and QUIC transports. These listeners run on shard 0 and delegate accepted connections to owning shards, with TLS and WebSocket handshakes performed in the install path to prevent slow peers from blocking the accept loop. The implementation also introduces runtime configuration for QUIC tuning and WebSocket frame layers, ensuring that socket options like TCP\_NODELAY are correctly applied and that handshake timeouts are enforced to mitigate slowloris-style attacks. Also in this area: Replica links now spread over multiple connections per peer; Bounded deferred (long) polling for consumers.

(repo-wide) · high confidence

Node.js client adds connection string support and VSR protocol features

The Node.js client now accepts a connection string (e.g., \iggy://user:pass@host:port\) for initialization, parsing transport, credentials, TLS, and reconnection options. It enforces stricter client configuration validation, including bounds on heartbeat and reconnect intervals, and a max response frame size. The client now supports TLS transport, automatic reconnection with configurable retries and intervals, and heartbeats to maintain connection health. Additionally, it includes BDD tests using Cucumber for end-to-end verification of core operations like stream/topic creation, message send/poll, and raw command execution.

foreign/node · high confidence

Python SDK renamed to apache-iggy with full feature parity

The Python SDK has been renamed from \iggy\_py\ to \apache-iggy\ and rewritten to align with the Rust SDK's architecture. This update introduces a comprehensive client API including TCP, QUIC, HTTP, and WebSocket transport configurations, high-level producer and consumer interfaces with partitioning strategies, and full user and permission management. It also adds support for consumer groups, message partitioning, and async iteration, providing a complete, modern Python client for Apache Iggy. Also in this area: Bounded deferred (long) polling for consumers; Send raw commands to a specific cluster replica.

foreign/python · high confidence

Repository governance and developer tooling configuration

The repository now includes foundational configuration files for Apache Software Foundation (ASF) governance and developer workflows. This adds \.asf.yaml\ to define GitHub repository settings, branch protection, and mailing list notifications; \.pre-commit-config.yaml\ to enforce code quality via hooks for Rust, Python, TOML, and Markdown; and \.typos.toml\ to configure spelling checks. Additionally, new files such as \AGENTS.md\ (AI agent guidelines), \CONTRIBUTING.md\ (contribution standards), \SECURITY.md\ (vulnerability reporting), and license/notice files (\ASF\_LICENSE.txt\, \NOTICE\) have been added to standardize project operations and compliance.

(repo-wide) · high confidence

Repository skills made available to Codex

New symbolic links have been added to the .agents/skills directory, pointing to existing skills in .claude/skills. This change exposes connector-related skills (such as connector-review, connector-runtime, connector-sdk, connector-sink, connector-source, connector-testing, connector-transform, and connectors-overview) as well as team-review and team-review-slim, making them accessible to the Codex agent.

.agents · high confidence

Rust SDK restructured with new transport configuration and leader-aware failover

The Rust SDK has been reorganized into smaller packages and now features a new \ClientProvider\ that centralizes configuration for TCP, QUIC, HTTP, and WebSocket transports, including dedicated reconnection and heartbeat settings for each. A new leader-aware connection mechanism automatically detects the cluster leader and redirects client requests, improving availability during node failures. Additionally, the SDK introduces a \consume\_messages\ extension for \IggyConsumer\ that simplifies message processing loops with automatic offset committing and graceful shutdown support.

core/sdk/src · high confidence

Text-based benchmark report formatting for titles and subtext

The benchmark reporting module now includes dedicated text-based formatting for report titles and subtext. The new \title\ module generates report headers that optionally include a user-provided remark, while the \subtext\ module constructs detailed summary lines displaying benchmark parameters (such as actors, streams, partitions, and message sizes) alongside key performance metrics including latency percentiles (P95, P99, etc.) and throughput statistics. This change provides a structured, human-readable text representation of benchmark results, specifically handling total system throughput for producer/consumer scenarios.

core/bench/report/src/plotting/text · high confidence

Topic and TopicDetails models now include extensible ResourceOptions

The Topic and TopicDetails structs in the common types module now feature an \options\ field of type \ResourceOptions\, allowing users to configure settings such as message expiry, compression, and size caps. Both structs also expose a \resolved\_options()\ method that returns typed, catalog-default-resolved settings, enabling clients to easily access effective configuration values.

core/common/src/types/topic · high confidence

Unified client wrapper for all transport protocols

The SDK now exposes a single \ClientWrapper\ enum that unifies access to Iggy, HTTP, TCP, QUIC, and WebSocket transports. This wrapper implements all common client interfaces (system, stream, topic, partition, message, consumer group, user, personal access token, segment, cluster, and consumer offset), allowing users to interact with the same API surface regardless of the underlying connection protocol.

core/sdk/src/clients · high confidence

Unified client wrapper with static dispatch for all transport protocols

The SDK now exposes a single \ClientWrapper\ enum that unifies access to Iggy, HTTP, TCP, QUIC, and WebSocket transports. This wrapper implements all common client traits (such as \Client\, \MessageClient\, \StreamClient\, \TopicClient\, \UserClient\, \SystemClient\, \ConsumerGroupClient\, and \ClusterClient\) by routing method calls to the underlying concrete client via a new \dispatch\_client!\ macro. This change provides a consistent API surface for users regardless of the chosen transport protocol, while also introducing connection info retrieval and deferred consumer group state management.

_core/sdk/src/client\wrappers · high confidence

WebSocket transport support added to the Rust SDK

The Rust SDK now includes a new WebSocket client implementation, allowing users to connect to Iggy clusters via WebSocket (both plain and TLS) in addition to the existing TCP transport. This change introduces the \WebSocketClient\ and associated stream types (\WebSocketConnectionStream\, \WebSocketTlsConnectionStream\) within the \core/sdk/src/websocket\ module, enabling WebSocket-based communication for standard client operations.

core/sdk/src/websocket · high confidence

Removals

Removal of legacy UDP-based server implementation

The server's legacy UDP transport layer has been removed. This change deletes the \args.rs\ configuration, the \command.rs\ dispatcher, and all specific protocol handlers (ping, poll, send, create/delete/get topics) that previously processed raw binary frames over UDP. Consequently, the server no longer supports this specific binary protocol, which was bound to \127.0.0.1:8080\ by default.

server · high confidence

Removed legacy UDP-based client application

The original UDP-based client application has been removed from the codebase. This change deletes the main entry point, the command parsing logic, and all specific command handlers (such as ping, send, poll, and topic management) that previously communicated with the server over UDP. This clears the way for the new SDK and transport implementations (HTTP/QUIC) referenced in the commit history.

client · high confidence

Removed placeholder SDK library code

The placeholder implementation in the SDK library (specifically the \add\ function and its associated test) has been removed. This cleanup eliminates unused boilerplate code from the public API surface.

sdk · high confidence

Security

CLI now wraps credentials in SecretString to prevent leaks

The CLI's credential handling in core/cli/src has been refactored to store sensitive data (passwords, tokens) using the SecretString type from the secrecy crate. This change ensures that credentials are not accidentally exposed in logs or memory dumps, improving security for login, context, and personal access token operations.

core/cli/src · high confidence

Architecture

New server\_common crate consolidates shared server infrastructure

The \server\_common\ crate has been introduced to centralize server-side components previously scattered across the codebase. This new module provides shared implementations for directory bootstrapping and cleanup, memory-pooled buffers, self-signed certificate generation, password hashing, and shard executor configuration. It also includes low-level I/O utilities such as aligned I/O buffers, consensus message framing, and file preallocation helpers, along with comprehensive diagnostics for Linux io\_uring runtime errors. This consolidation supports the ongoing migration to the new server architecture by providing a common foundation for these core services.

_core/server\common/src · high confidence

Refactored partition journal to use a pluggable storage trait

The partition journal implementation has been refactored to depend on a new \DurableStorage\ trait rather than a concrete file-storage implementation. This change introduces a \durable\_storage\ module defining the storage interface and a \file\_storage\ module providing the default file-backed implementation, allowing the journal to be decoupled from specific I/O mechanisms and enabling easier testing and potential future storage backends.

core/journal · high confidence

Refactored server boot process into a modular boot directory

The server startup sequence has been reorganized from a single \bootstrap.rs\ file into a structured \core/server/src/boot/\ module. This change splits the boot logic into distinct, focused components: \credentials.rs\ handles root user initialization and TLS/PSK material, \fd\_limit.rs\ manages the process's open file descriptor limits and client connection caps, \handoff.rs\ coordinates cross-shard metadata bundle distribution and listener barriers, \listeners.rs\ manages TCP, WS, QUIC, and HTTP listener startup, \recovery.rs\ drives shard construction and partition recovery, \systemd.rs\ wraps systemd notification and watchdog integration, and \threads.rs\ handles OS thread creation, pinning, and shutdown coordination. This modularization improves code maintainability and separation of concerns during the server's initialization phase.

core/server/src/boot · high confidence

Refactored server dispatch into explicit, modular components

The server's request dispatch logic has been restructured from a monolithic implementation into a set of distinct, plane-named modules (authz, failure, host, login\_error, metadata\_changes, partition, reads, session\_ops, submit). This change makes the routing and failure paths explicit, separating authorization gates, frame delivery channels, session management, and partition-specific request handling into their own files for better maintainability and clarity.

core/server/src/dispatch · high confidence

Behavioural changes

1 commit (0 fixes) modifying core/bench/dashboard/frontend/src/pages

A change to existing behaviour in core/bench/dashboard/frontend/src/pages — 1 commit, 23 files: “feat(bench): rebuild the benchmark dashboard around comparable runs (\#4885)” (refs \#4885).

core/bench/dashboard/frontend/src/pages · medium confidence · unverified

1 commit (0 fixes) modifying examples/swift

A change to existing behaviour in examples/swift — 1 commit, 4 files: “feat(swift): add connection strings, examples and BDD suite (\#4679)” (refs \#4679).

examples/swift · medium confidence · unverified

1 commit (0 fixes) modifying helm/charts/iggy-kafka-gateway

A change to existing behaviour in helm/charts/iggy-kafka-gateway — 1 commit, 14 files: “feat(gateways): add Kafka gateway metrics, readiness and a Helm chart (\#4783)” (refs \#4783).

helm/charts/iggy-kafka-gateway · medium confidence · unverified

10 commits (1 fix) modifying core/common/src/types/options

A change to existing behaviour in core/common/src/types/options — 10 commits (1 fix), 6 files: “feat(partitions)!: fence ownership and history changes (\#4456)”; “feat(server): enable tiered storage on a topic (\#4856)”; “feat(server): add the tiered storage topic options (\#4843)”; and 7 more (refs \#4456, \#4856, \#4843, \#3880, \#4615, …).

core/common/src/types/options · medium confidence · unverified

10 commits (3 fixes) modifying core/bench/dashboard/frontend/src/components

A change to existing behaviour in core/bench/dashboard/frontend/src/components — 10 commits (3 fixs), 11 files: “feat(repo): move iggy-benchmarks-dashboard to monorepo (\#1769)”; “feat(bench): introduce benchmark deep linking and 'Recent' tab (\#1773)”; “feat(bench): redesign benchmarks dashboard with landing + compare mode (\#3145)”; and 7 more (refs \#1769, \#1773, \#3145, \#4885, \#2795, …).

core/bench/dashboard/frontend/src/components · medium confidence · unverified

11 commits (1 fix) modifying bdd/scenarios

A change to existing behaviour in bdd/scenarios — 11 commits (1 fix), 9 files: “feat(io\_uring): implement thread per core io\_uring (\#2299)”; “feat(cluster)!: spread and rebalance partition primaries (\#4619)”; “feat(bdd): add Python BDD tests and reorganize test structure (\#1909)”; and 8 more (refs \#2299, \#4619, \#1909, \#3384, \#4683, …).

bdd/scenarios · medium confidence · unverified

A change to existing behaviour in core/sdk/src/links — 12 commits (3 fixs), 7 files: “feat(cluster)!: spread and rebalance partition primaries (\#4619)”; “fix: preserve JSON numbers and synchronize mux cancellation tests (\#4733)”; “feat(server)!: replace readiness waits with grouped deferred fetches (\#4683)”; and 9 more (refs \#4619, \#4733, \#4683, \#4615, \#4803, …).

core/sdk/src/links · medium confidence · unverified

13 commits (6 fixes) modifying core/message\_bus/src/client\_listener

A change to existing behaviour in core/message\_bus/src/client\_listener — 13 commits (6 fixs), 6 files: “feat(sdk): implement vsr header framing (\#3254)”; “feat(server): guard against running out of file descriptors (\#4318)”; “feat(server-ng): harden listener, auth, shutdown, and disk-poll paths (\#3774)”; and 10 more (refs \#3254, \#4318, \#3774, \#3585, \#3399, …).

_core/message\_bus/src/client\listener · medium confidence · unverified

14 commits (1 fix) modifying bdd/cpp/features/step\_definitions

A change to existing behaviour in bdd/cpp/features/step\_definitions — 14 commits (1 fix), 9 files: “test(bdd): add C++ SDK BDD tests for basic messaging (\#3554)”; “fix(bdd): resolve server address and credentials only from env (\#3935)”; “feat(cpp): add functions related to client lifecycle, and message headers (\#3610)”; and 11 more (refs \#3554, \#3935, \#3610, \#4619, \#3880, …).

_bdd/cpp/features/step\definitions · medium confidence · unverified

14 commits (1 fix) modifying core/common/src/types/consumer

A change to existing behaviour in core/common/src/types/consumer — 14 commits (1 fix), 8 files: “feat(partitions)!: fence ownership and history changes (\#4456)”; “feat(gateways): share Kafka consumer groups across multiple gateways in Iggy (\#4681)”; “chore(repo): update Rust edition to 2024 across multiple Cargo.toml files (\#1772)”; and 11 more (refs \#4456, \#4681, \#1772, \#4348, \#2341, …).

core/common/src/types/consumer · medium confidence · unverified

15 commits (4 fixes) modifying core/sdk/src/stream\_builder/config

A change to existing behaviour in core/sdk/src/stream\_builder/config — 15 commits (4 fixs), 4 files: “feat(sdk): add background sending support to IggyProducer (\#1838)”; “refactor(sdk): introduce NonZeroIggyDuration for retries and heartbeats (\#3891)”; “feat(consensus): persist retry receipts and shared sessions (\#4387)”; and 12 more (refs \#1838, \#3891, \#4387, \#4151, \#3880, …).

_core/sdk/src/stream\builder/config · medium confidence · unverified

16 commits (6 fixes) modifying core/simulator/src/storage

A change to existing behaviour in core/simulator/src/storage — 16 commits (6 fixs), 2 files: “fix(cluster,sdk)!: prevent partition stalls and lost reader batches (\#4868)”; “feat(partitions)!: fence ownership and history changes (\#4456)”; “fix(partitions): account for segment-backed append batches (\#4202)”; and 13 more (refs \#4868, \#4456, \#4202, \#4278, \#4146, …).

core/simulator/src/storage · medium confidence · unverified

17 commits (2 fixes) modifying examples/go

A change to existing behaviour in examples/go — 17 commits (2 fixs), 15 files: “feat(example): add Go message envelope producer and consumer (\#4758)”; “ci: add pre-commit hooks for all SDKs (\#2676)”; “fix(server)!: reject a wildcard bind with no advertised address (\#3923)”; and 14 more (refs \#4758, \#2676, \#3923, \#2017, \#2299, …).

examples/go · medium confidence · unverified

18 commits (4 fixes) modifying core/harness\_derive

A change to existing behaviour in core/harness\_derive — 18 commits (4 fixs), 4 files: “feat(connectors): implement InfluxDB Sink and Source (\#2933)”; “revert(test): remove shared\_server, add nextest CI retries (\#3088)”; “feat(sdk): implement vsr header framing (\#3254)”; and 15 more (refs \#2933, \#3088, \#3254, \#3085, \#3895, …).

_core/harness\derive · medium confidence · unverified

19 commits (3 fixes) modifying core/integration/src

A change to existing behaviour in core/integration/src — 19 commits (3 fixs), 2 files: “revert(test): remove shared\_server, add nextest CI retries (\#3088)”; “feat(partitions): implement state transfer (\#3808)”; “test(connectors): create E2E test suite for connectors, refactor config provider (\#2190)”; and 16 more (refs \#3088, \#3808, \#2190, \#3085, \#2158, …).

core/integration/src · medium confidence · unverified

2 commits (0 fixes) modifying bdd/swift

A change to existing behaviour in bdd/swift — 2 commits, 9 files: “feat(server)!: replace readiness waits with grouped deferred fetches (\#4683)”; “feat(swift): add connection strings, examples and BDD suite (\#4679)” (refs \#4683, \#4679).

bdd/swift · medium confidence · unverified

2 commits (0 fixes) modifying core/web\_ui

A change to existing behaviour in core/web\_ui — 2 commits, 19 files: “feat(web): add Dioxus web UI crate with streams browser (\#4644)”; “ci: run slow Miri tests nightly, bump Rust to 1.100.0, drop unused deps (\#4882)” (refs \#4644, \#4882).

_core/web\ui · medium confidence · unverified

2 commits (0 fixes) modifying examples/python/message-headers

A change to existing behaviour in examples/python/message-headers — 2 commits, 4 files: “feat(python): let poll\_messages take a consumer (\#3877)”; “feat(python): add user header and origin timestamp support (\#3613)” (refs \#3877, \#3613).

examples/python/message-headers · medium confidence · unverified

20 commits (3 fixes) modifying core/ai/mcp/src/service

A change to existing behaviour in core/ai/mcp/src/service — 20 commits (3 fixs), 2 files: “fix(mcp): document allowed values for poll strategy and partitioning (\#4588)”; “chore(deps): upgrade rust dependencies, update readmes with docker hub (\#2139)”; “chore(repo): upgrade deps and bump Rust to 1.97.1 (\#3720)”; and 17 more (refs \#4588, \#2139, \#3720, \#3123, \#4843, …).

core/ai/mcp/src/service · medium confidence · unverified

21 commits (3 fixes) modifying core/simulator/src/workload/ops

A change to existing behaviour in core/simulator/src/workload/ops — 21 commits (3 fixs), 28 files: “feat(cpp): run C++ SDK tests only against the VSR server (\#3844)”; “fix(metadata): enforce namespace caps at admission to stop aliasing (\#3907)”; “feat(simulator): deterministic seed based workload fuzz harness (\#3272)”; and 18 more (refs \#3844, \#3907, \#3272, \#4456, \#3904, …).

core/simulator/src/workload/ops · medium confidence · unverified

21 commits (5 fixes) modifying examples/java

A change to existing behaviour in examples/java — 21 commits (5 fixs), 5 files: “refactor(server): compile-time env var mappings eliminate runtime ambiguity (\#2614)”; “fix(server)!: reject a wildcard bind with no advertised address (\#3923)”; “fix(server)!: drop generated root passwords, journal root, gate snapshots (\#4585)”; and 18 more (refs \#2614, \#3923, \#4585, \#3841, \#2659, …).

examples/java · medium confidence · unverified

24 commits (5 fixes) modifying php

A change to existing behaviour in php — 24 commits (5 fixs), 1 file: “fix(cluster,sdk)!: prevent partition stalls and lost reader batches (\#4868)”; “feat(partitions)!: fence ownership and history changes (\#4456)”; “fix(ci,php): survive the zip crate mass yank (\#4574)”; and 21 more (refs \#4868, \#4456, \#4574, \#4843, \#3463, …).

php · medium confidence · unverified

27 commits (4 fixes) modifying core/simulator/src/workload

A change to existing behaviour in core/simulator/src/workload — 27 commits (4 fixs), 12 files: “feat(cpp): run C++ SDK tests only against the VSR server (\#3844)”; “feat(simulator): deterministic seed based workload fuzz harness (\#3272)”; “feat(partitions)!: fence ownership and history changes (\#4456)”; and 24 more (refs \#3844, \#3272, \#4456, \#4063, \#3904, …).

core/simulator/src/workload · medium confidence · unverified

34 commits (7 fixes) modifying core/common/src/traits/binary\_impls

A change to existing behaviour in core/common/src/traits/binary\_impls — 34 commits (7 fixs), 12 files: “feat(partitions)!: fence ownership and history changes (\#4456)”; “feat(sdk): implement vsr header framing (\#3254)”; “fix(server-ng): fix restart/reconnect hardening and cg integration tests (\#3625)”; and 31 more (refs \#4456, \#3254, \#3625, \#3904, \#3527, …).

_core/common/src/traits/binary\impls · medium confidence · unverified

4 commits (0 fixes) modifying core/system\_stats

A change to existing behaviour in core/system\_stats — 4 commits, 2 files: “feat(server): guard against running out of file descriptors (\#4318)”; “feat: respect CPU and cgroup limits in server-ng and connectors stats (\#3647)”; “feat(cluster)!: spread and rebalance partition primaries (\#4619)”; and 1 more (refs \#4318, \#3647, \#4619, \#4731).

_core/system\stats · medium confidence · unverified

4 commits (0 fixes) modifying foreign/java/buildSrc

A change to existing behaviour in foreign/java/buildSrc — 4 commits, 3 files: “ci(Java): add JaCoCo code coverage with Codecov integration (\#2623)”; “chore(java): update project dependencies and unify dependencies versions in version catalog (\#2410)”; “feat(java): let clients close without Netty's 2 s quiet period (\#4704)”; and 1 more (refs \#2623, \#2410, \#4704, \#4626).

foreign/java/buildSrc · medium confidence · unverified

4 commits (1 fix) modifying examples/java/src/main/java/org/apache/iggy/examples/messageenvelope/consumer

A change to existing behaviour in examples/java/src/main/java/org/apache/iggy/examples/messageenvelope/consumer — 4 commits (1 fix), 1 file: “fix(sdk): preserve consumer progress and client error handling (\#4151)”; “refactor(java): unify blocking TCP client as wrapper over async client (\#2947)”; “chore(docs): add java examples and ci tests (\#2504)”; and 1 more (refs \#4151, \#2947, \#2504, \#2630).

examples/java/src/main/java/org/apache/iggy/examples/messageenvelope/consumer · medium confidence · unverified

40 commits (4 fixes) modifying foreign/cpp

A change to existing behaviour in foreign/cpp — 40 commits (4 fixs), 12 files: “fix(cluster,sdk)!: prevent partition stalls and lost reader batches (\#4868)”; “feat(partitions)!: fence ownership and history changes (\#4456)”; “feat(cpp): add functions related to system (\#3102)”; and 37 more (refs \#4868, \#4456, \#3102, \#3046, \#4318, …).

foreign/cpp · medium confidence · unverified

41 commits (9 fixes) modifying core/integration/src/harness

A change to existing behaviour in core/integration/src/harness — 41 commits (9 fixs), 13 files: “revert(test): remove shared\_server, add nextest CI retries (\#3088)”; “feat(partitions)!: fence ownership and history changes (\#4456)”; “fix(partitions): bound consumer offset state per partition (\#4063)”; and 38 more (refs \#3088, \#4456, \#4063, \#3254, \#3957, …).

core/integration/src/harness · medium confidence · unverified

44 commits (6 fixes) modifying core/sdk/src/http

A change to existing behaviour in core/sdk/src/http — 44 commits (6 fixs), 20 files: “fix(consensus): preserve recovery floors and reject aged-out requests (\#4365)”; “feat(partitions)!: fence ownership and history changes (\#4456)”; “feat(connectors): log retry request with URL details (\#2457)”; and 41 more (refs \#4365, \#4456, \#2457, \#3720, \#4848, …).

core/sdk/src/http · medium confidence · unverified

5 commits (0 fixes) modifying core/common/src/types/partition

A change to existing behaviour in core/common/src/types/partition — 5 commits, 1 file: “feat(partitions)!: fence ownership and history changes (\#4456)”; “feat(python): expose remaining Topic/TopicDetails fields and partitions (\#3623)”; “ci: replace \addlicense\ with \HawkEye\ for license header checks (\#3325)”; and 2 more (refs \#4456, \#3623, \#3325, \#1755, \#4692).

core/common/src/types/partition · medium confidence · unverified

5 commits (0 fixes) modifying core/kafka\_wire

A change to existing behaviour in core/kafka\_wire — 5 commits, 15 files: “feat(gateways): share Kafka consumer groups across multiple gateways in Iggy (\#4681)”; “feat(gateways): accept SaslHandshake v0 from older Kafka clients (\#4778)”; “feat(gateways): serve ApiVersions v4 and v5 to Kafka 4 clients (\#4780)”; and 2 more (refs \#4681, \#4778, \#4780, \#4664, \#4691).

_core/kafka\wire · medium confidence · unverified

5 commits (1 fix) modifying examples/java/src/main/java/org/apache/iggy/examples/tcptls

A change to existing behaviour in examples/java/src/main/java/org/apache/iggy/examples/tcptls — 5 commits (1 fix), 2 files: “fix(sdk): preserve consumer progress and client error handling (\#4151)”; “refactor(java): unify blocking TCP client as wrapper over async client (\#2947)”; “feat(common)!: extensible key-value options for topics, streams, users (\#3880)”; and 2 more (refs \#4151, \#2947, \#3880, \#4615, \#2823).

examples/java/src/main/java/org/apache/iggy/examples/tcptls · medium confidence · unverified

5 commits (1 fix) modifying examples/php

A change to existing behaviour in examples/php — 5 commits (1 fix), 8 files: “feat(php): add SDK examples component (\#3368)”; “fix(sdk): preserve consumer progress and client error handling (\#4151)”; “feat(server)!: replace readiness waits with grouped deferred fetches (\#4683)”; and 2 more (refs \#3368, \#4151, \#4683, \#3325, \#4718).

examples/php · medium confidence · unverified

5 commits (2 fixes) modifying core/bench/dashboard/server/src/cache

A change to existing behaviour in core/bench/dashboard/server/src/cache — 5 commits (2 fixs), 5 files: “feat(repo): move iggy-benchmarks-dashboard to monorepo (\#1769)”; “feat(bench): rebuild the benchmark dashboard around comparable runs (\#4885)”; “fix(server): refactor Rust code based on clippy lints (\#1918)”; and 2 more (refs \#1769, \#4885, \#1918, \#2833, \#2091).

core/bench/dashboard/server/src/cache · medium confidence · unverified

6 commits (0 fixes) modifying core/object\_store

A change to existing behaviour in core/object\_store — 6 commits, 23 files: “feat(server): add the per-shard tier service (\#4876)”; “feat(server): verify the object store identity at boot (\#4888)”; “feat(storage): refresh object store credentials (\#4895)”; and 3 more (refs \#4876, \#4888, \#4895, \#4869, \#4894, …).

_core/object\store · medium confidence · unverified

6 commits (0 fixes) modifying core/server\_common/src/segment\_storage

A change to existing behaviour in core/server\_common/src/segment\_storage — 6 commits, 3 files: “refactor(sdk)!: remove v2 bridges and legacy message wire format (\#3904)”; “feat(server): guard against running out of file descriptors (\#4318)”; “refactor(server): extract server-only types into new crate \server\_common\ (\#3298)”; and 3 more (refs \#3904, \#4318, \#3298, \#4311, \#4092, …).

_core/server\_common/src/segment\storage · medium confidence · unverified

6 commits (1 fix) modifying core/bench/dashboard/shared

A change to existing behaviour in core/bench/dashboard/shared — 6 commits (1 fix), 9 files: “feat(repo): move iggy-benchmarks-dashboard to monorepo (\#1769)”; “feat(bench): introduce benchmark deep linking and 'Recent' tab (\#1773)”; “feat(bench): record cluster topology in reports and surface it in UI (\#3737)”; and 3 more (refs \#1769, \#1773, \#3737, \#4885, \#2832, …).

core/bench/dashboard/shared · medium confidence · unverified

6 commits (1 fix) modifying examples/java/src/main/java/org/apache/iggy/examples/gettingstarted, examples/java/src/main/java/org/apache/iggy/examples/streambuilder, java-examples

A change to existing behaviour in examples/java/src/main/java/org/apache/iggy/examples/gettingstarted, examples/java/src/main/java/org/apache/iggy/examples/streambuilder, java-examples — 6 commits (1 fix), 7 files: “fix(sdk): preserve consumer progress and client error handling (\#4151)”; “refactor(java): unify blocking TCP client as wrapper over async client (\#2947)”; “feat(common)!: extensible key-value options for topics, streams, users (\#3880)”; and 3 more (refs \#4151, \#2947, \#3880, \#4615, \#2504, …).

examples/java/src/main/java/org/apache/iggy/examples/gettingstarted, examples/java/src/main/java/org/apache/iggy/examples/streambuilder, java-examples · medium confidence · unverified

6 commits (2 fixes) modifying core/bench/dashboard/frontend/src/api

A change to existing behaviour in core/bench/dashboard/frontend/src/api — 6 commits (2 fixs), 1 file: “feat(repo): move iggy-benchmarks-dashboard to monorepo (\#1769)”; “feat(bench): introduce benchmark deep linking and 'Recent' tab (\#1773)”; “chore(repo): bump Rust toolchain to 1.99.0 (\#4430)”; and 3 more (refs \#1769, \#1773, \#4430, \#4885, \#1918, …).

core/bench/dashboard/frontend/src/api · medium confidence · unverified

65 commits (11 fixes) modifying examples/python

A change to existing behaviour in examples/python — 65 commits (11 fixs), 6 files: “chore(deps): Bump the python group across 3 directories with 3 updates (\#3593)”; “feat(python): add stream listing, update, delete, and purge (\#3701)”; “chore(deps): Update testcontainers requirement from \<5.0,\>=3.7.0 to \>=4.15.0,\<5.0 in /bdd/python (\#3826)”; and 62 more (refs \#3593, \#3701, \#3826, \#4315, \#4063, …).

examples/python · medium confidence · unverified

66 commits (20 fixes) modifying core/configs/src/server\_config

A change to existing behaviour in core/configs/src/server\_config — 66 commits (20 fixs), 16 files: “fix(metadata): enforce namespace caps at admission to stop aliasing (\#3907)”; “feat(partitions)!: fence ownership and history changes (\#4456)”; “fix(partitions): bound consumer offset state per partition (\#4063)”; and 63 more (refs \#3907, \#4456, \#4063, \#3578, \#3915, …).

_core/configs/src/server\config · medium confidence · unverified

7 commits (0 fixes) modifying examples/java/src/main/java/org/apache/iggy/examples/messageenvelope/producer

A change to existing behaviour in examples/java/src/main/java/org/apache/iggy/examples/messageenvelope/producer — 7 commits, 1 file: “refactor(java): unify blocking TCP client as wrapper over async client (\#2947)”; “feat(common)!: extensible key-value options for topics, streams, users (\#3880)”; “feat(server)!: unify resource options and add per-stream keys (\#4615)”; and 4 more (refs \#2947, \#3880, \#4615, \#2516, \#2504, …).

examples/java/src/main/java/org/apache/iggy/examples/messageenvelope/producer · medium confidence · unverified

7 commits (1 fix) modifying examples/java/src/main/java/org/apache/iggy/examples/messageheaders

A change to existing behaviour in examples/java/src/main/java/org/apache/iggy/examples/messageheaders — 7 commits (1 fix), 2 files: “fix(sdk): preserve consumer progress and client error handling (\#4151)”; “feat(server,sdk): allow arbitrary (non-string) header key kind (\#2637)”; “refactor(java): unify blocking TCP client as wrapper over async client (\#2947)”; and 4 more (refs \#4151, \#2637, \#2947, \#3880, \#4615, …).

examples/java/src/main/java/org/apache/iggy/examples/messageheaders · medium confidence · unverified

8 commits (0 fixes) modifying bdd/java/gradle, examples/java/gradle

A change to existing behaviour in bdd/java/gradle, examples/java/gradle — 8 commits, 2 files: “chore(deps): Bump the java group across 3 directories with 3 updates (\#4665)”; “feat(java): add gradle wrapper with jar file autofetch (\#2659)”; “chore(deps): Bump the java group across 3 directories with 10 updates (\#4548)”; and 5 more (refs \#4665, \#2659, \#4548, \#4427, \#3563, …).

bdd/java/gradle, examples/java/gradle · medium confidence · unverified

9 commits (0 fixes) modifying core/common

A change to existing behaviour in core/common — 9 commits, 22 files: “feat(server): add the tiered storage topic options (\#4843)”; “chore(repo): add ASF incubator status and update readme (\#3208)”; “chore(repo): remove incubating references after TLP graduation (\#3928)”; and 6 more (refs \#4843, \#3208, \#3928, \#4683, \#4615, …).

core/common · medium confidence · unverified

9 commits (1 fix) modifying github.com/apache/iggy/foreign/go

A change to existing behaviour in github.com/apache/iggy/foreign/go — 9 commits (1 fix), 3 files: “feat(partitions)!: fence ownership and history changes (\#4456)”; “chore(repo): migrate go sdk (\#1736)”; “feat(cluster)!: spread and rebalance partition primaries (\#4619)”; and 6 more (refs \#4456, \#1736, \#4619, \#1766, \#4683, …).

github.com/apache/iggy/foreign/go · medium confidence · unverified

9 commits (2 fixes) modifying .devcontainer

A change to existing behaviour in .devcontainer — 9 commits (2 fixs), 4 files: “chore(repo): upgrade deps and bump Rust to 1.97.1 (\#3720)”; “chore(repo): bump Rust toolchain to 1.99.0 (\#4430)”; “chore(repo): bump Rust toolchain to 1.98.0 (\#3962)”; and 6 more (refs \#3720, \#4430, \#3962, \#3923, \#4882, …).

.devcontainer · medium confidence · unverified

9 commits (3 fixes) modifying core/bench/dashboard/frontend/src

A change to existing behaviour in core/bench/dashboard/frontend/src — 9 commits (3 fixs), 8 files: “feat(repo): move iggy-benchmarks-dashboard to monorepo (\#1769)”; “feat(bench): introduce benchmark deep linking and 'Recent' tab (\#1773)”; “feat(bench): redesign benchmarks dashboard with landing + compare mode (\#3145)”; and 6 more (refs \#1769, \#1773, \#3145, \#4885, \#3146, …).

core/bench/dashboard/frontend/src · medium confidence · unverified

Benchmark CLI argument parsing is restructured into a modular, typed system

The \core/bench/src/args\ module has been completely rewritten to replace the previous ad-hoc argument handling with a structured, modular approach using \clap\. This change introduces dedicated modules for common arguments (\common.rs\), default values (\defaults.rs\), benchmark kinds (\kind.rs\), and transport protocols (\transport.rs\). Users benefit from a more robust CLI that enforces validation rules (such as mutual exclusivity between \--message-batches\ and \--total-data\), provides clearer help text and examples (\examples.rs\), and supports a wider range of configuration options including TLS for TCP, QUIC client binding, and detailed output management. The new structure also adds support for specific benchmark kinds like \BalancedConsumerGroup\ and \EndToEndProducingConsumer\ with their own argument sets, ensuring that transport-specific options (like \nodelay\ for TCP) are correctly scoped and validated.

core/bench/src/args · high confidence

Benchmark tool refactored to support high-level API and new benchmark modes

The benchmarking tool in core/bench has been restructured to support the Iggy high-level API for producers and consumers, introducing new benchmark types such as BalancedProducer, BalancedConsumerGroup, and EndToEndProducingConsumer alongside the existing Pinned variants. This change replaces the previous TestServer startup capability with a ClientFactory abstraction, allowing benchmarks to run against live servers. It also adds configurable topic options including message expiry, durability, and read amplification to better simulate real-world conditions and prevent corrupted latency measurements.

core/bench/src/benchmarks · high confidence

Benchmark utility library refactored into modular components

The benchmarking tool's internal utilities have been restructured into distinct, reusable modules to improve code organization and maintainability. The new layout includes \batch\_generator\ for constructing message payloads, \client\_factory\ for abstracting client creation across different transport protocols (HTTP, TCP, QUIC, WebSocket), \cpu\_name\ for hardware identification, \finish\_condition\ for managing benchmark termination logic, \rate\_limiter\ for controlling throughput, and a consolidated \mod.rs\ for shared helpers. This change isolates specific concerns within the benchmarking infrastructure, making it easier to extend or modify individual aspects of the benchmarking process without affecting the entire system.

core/bench/src/utils · high confidence

CLI binary message commands now support headers and file input

The CLI's binary message commands have been updated to support message headers and reading payloads from files. The \send\_messages\ command can now accept user-defined headers and read message data from an input file or stdin, while the \poll\_messages\ command can optionally display these headers in its output table.

_core/cli/src/commands/binary\message · high confidence

CLI permission argument handling refactored and reorganized

The CLI permission argument handling code has been moved from the \cmd\ crate to \core/cli/src/args/permissions\, and the internal data structures for stream and topic IDs have been changed from \u32\ to \usize\. Additionally, the implementation now uses \BTreeMap\ instead of \HashMap\ for storing stream and topic permissions, and imports for \GlobalPermissions\, \StreamPermissions\, \TopicPermissions\, and \UserStatus\ have been updated to use the \iggy::prelude\ module.

core/cli/src/args/permissions · high confidence

Centralized error handling and eviction reason mapping

The error types have been reorganized into the \core/common/src/error\ module, moving \ClientError\ from the SDK to the common crate and introducing a new \eviction.rs\ module. This module provides a unified \eviction\_reason\_to\_error\ function that maps wire-level \EvictionReason\ codes (such as \InvalidCredentials\, \IncompatibleProtocol\, and \StaleClient\) to specific \IggyError\ variants, ensuring consistent error reporting across TCP, QUIC, WebSocket, and HTTP transports. The \IggyError\ enum itself has been expanded with new variants like \TransientNotCommitted\, \TransientNotAccepted\, and \RequestAlreadyApplied\ to support improved commit-time metadata validation and retry semantics.

core/common/src/error · high confidence

Compile-time environment variable mappings replace runtime ambiguity

The configuration system now uses compile-time generated mappings to resolve environment variables, eliminating the previous runtime ambiguity in path resolution. This change introduces a \ConfigEnv\ derive macro that produces static mappings, a \TypedEnvProvider\ that validates against known variable names (refusing to boot on unknowns in debug builds), and a \FileConfigProvider\ that explicitly rejects relocated or removed configuration keys with clear guidance. Users benefit from stricter validation, deterministic error messages, and the ability to migrate obsolete settings before they cause silent failures.

_core/configs/src/configs\impl · high confidence

Expanded server statistics with system resource and cache metrics

The server's stats response now includes detailed system resource information, specifically the number of threads, free disk space, and total disk space for the data directory. Additionally, per-partition cache metrics (hits, misses, and hit ratio) are exposed, allowing users to monitor cache performance. The stats structure also now respects CPU affinity and cgroup limits for accurate CPU and memory usage reporting.

core/common/src/types/stats · high confidence

HTTP client configuration now supports address validation and connection string parsing

The HTTP client configuration module has been restructured to include stricter validation and easier setup. The \HttpClientConfigBuilder\ now automatically trims whitespace and validates the API URL before building the configuration, rejecting invalid addresses. Additionally, a new \HttpConnectionStringOptions\ implementation allows users to configure retry counts and heartbeat intervals by parsing them directly from a connection string, simplifying initialization for these specific settings.

_core/common/src/types/configuration/http\config · high confidence

Identifier type refactored with new error types and zero-value support

The Identifier type has been moved to core/common/src/types/identifier and refactored to use the specific IggyError::InvalidIdentifier error instead of the generic Error::InvalidCommand. This change allows numeric identifiers to accept zero as a valid value (previously rejected), supporting 0-based consumer groups and slab keys. Additionally, the type now implements Eq and provides new methods like get\_cow\_str\_value and as\_cow\_str for more efficient string handling.

core/common/src/types/identifier · high confidence

Introduce server-side sharding types and strict namespace packing

The \core/server\_common/src/sharding\ module now provides the foundational types for server-side partition routing, including \ShardId\, \LocalIdx\, \PartitionLocation\, and \IggyNamespace\. A key behavioral change is in \IggyNamespace::new\, which now strictly enforces stream, topic, and partition limits at admission; previously, out-of-range values were silently masked, causing different partitions to alias onto the same shard and consensus group. This fix ensures that metadata creation fails if limits are exceeded, preventing silent data corruption and routing errors.

_core/server\common/src/sharding · high confidence

New HTTP server architecture with admission control and follower forwarding

The HTTP server layer has been rewritten to introduce per-session and global in-flight write admission controls that prevent resource exhaustion, and a follower-side forwarding mechanism that automatically relays consensus-needing requests to the primary node so clients can connect to any cluster member without handling redirects.

core/server/src/http · high confidence

New TCP client configuration module with validation and connection-string support

The TCP client configuration has been restructured into a dedicated module (\core/common/src/types/configuration/tcp\_config\) containing a builder, reconnection settings, and connection-string parsing. Users can now configure TLS (domain, CA file, validation), automatic reconnection (retries, interval, cooldown), heartbeats, and Nagle's algorithm via a builder or a connection string. The builder validates server addresses (IP, hostname, port) at build time, rejecting invalid formats like unbracketed IPv6 or missing ports.

_core/common/src/types/configuration/tcp\config · high confidence

New VSR consensus wire protocol types and frame sealing

The binary protocol crate now defines the complete VSR (Viewstamped Replication) consensus wire format, introducing a new \Command\ enum with 31 message types (including replica auth, state transfer, and session heartbeats) and an \Operation\ enum for replicated state-machine actions. All consensus headers are fixed at 256 bytes with zero-copy deserialization and, critically, a new frame-sealing mechanism that cryptographically verifies header integrity on the wire. This is a breaking change for the replica-to-replica control plane: mixed-version clusters will drop all control frames and halt, so replicas must be upgraded together with the cluster down. Client-facing headers (Request, Reply, Eviction) and legacy Prepare frames are unaffected and remain backward-compatible with older SDKs.

_core/binary\protocol/src/consensus · high confidence

New common type definitions and statistics underflow protection

The \core/common/src/types\ module now includes new type definitions for \Either\, HTTP methods (\HttpMethod\), and \Segment\ state, alongside a comprehensive \streaming\_stats\ implementation. This implementation introduces atomic statistics counters for streams, topics, and partitions that clamp to zero instead of wrapping on underflow, preventing incorrect metric values in \/stats\ and \/metrics\ endpoints when rollup decrements exceed totals. A process-wide counter tracks these underflows, logging warnings to alert operators that a rebuild is needed.

core/common/src/types · high confidence

New message type definitions and zero-copy views in common types

The \core/common/src/types/message\ module has been restructured to introduce a new, explicit message wire format. This includes the \IggyMessage\ struct with defined payload and user-header size limits (64 MB and 100 KB respectively), and a 64-byte \IggyMessageHeader\ containing fields for checksum, ID, offset, timestamps, and header/payload lengths. To support efficient I/O, the update adds zero-copy view types (\IggyMessageView\, \IggyMessageHeaderView\, \IggyIndexView\) that allow reading message data directly from buffers without allocation. It also introduces \IggyIndexes\ for binary-encoded message indexing with timestamp-based binary search, and \IggyMessagesBatch\ to manage collections of messages with associated index data.

core/common/src/types/message · high confidence

New partition storage and offset management subsystem

The partitions module has been reworked to introduce a new storage layer and offset management system. This includes a new sparse index format (24-byte entries for offset, timestamp, and position) with dedicated readers and writers, replacing the legacy dense index. Consumer offset tracking is now handled by a new \DurableConsumerOffsets\ and \ConsumerOffsetCapacity\ system that enforces limits and manages auto-commit reservations. The core \IggyPartition\ struct has been updated to use this new journal and storage infrastructure, and a new \install\_backup\ mechanism ensures durable, atomic updates to partition files during state transfers or materialization.

core/partitions · high confidence

Permissions model refactored with consumer group support and improved serialization

The permissions module has been reorganized under \core/common/src/types/permissions\, moving global and personal access token definitions into a shared common location. The \Permissions\ struct now uses \BTreeMap\ instead of \HashMap\ for stream and topic collections to ensure deterministic ordering. Documentation and internal logic have been updated to reflect that \read\_topics\ and \read\_topic\ permissions now include consumer group management capabilities (create, join, leave, get). Additionally, the \PersonalAccessTokenInfo\ expiry field has been renamed to \expiry\_at\ and changed from a raw \u64\ to an \IggyTimestamp\ type, and the \GlobalPermissions\ struct now implements \Display\ via a formatted table for better readability.

core/common/src/types/permissions · high confidence

QUIC client configuration refactored with address validation and reconnection details

The QUIC client configuration module has been reorganized under \core/common/src/types/configuration/quic\_config\, introducing a builder pattern (\QuicClientConfigBuilder\) that validates and trims the server address upon build. The configuration structure now groups reconnection settings into a dedicated \QuicClientReconnectionConfig\ (supporting max retries, interval, and re-establish delay) and adds a \heartbeat\_interval\ field. Additionally, the module provides \QuicConnectionStringOptions\ to parse connection-string parameters for these settings and implements \From\<ConnectionString\>\ to convert parsed connection strings into the new configuration struct.

_core/common/src/types/configuration/quic\config · high confidence

Removed legacy streaming module files

The \streaming\ module's core implementation files—including \index.rs\, \lib.rs\, \message.rs\, \partition.rs\, \segment.rs\, \serialization.rs\, \stream.rs\, \stream\_error.rs\, \system.rs\, \timestamp.rs\, and \topic.rs\—have been deleted. This removes the previous monolithic definitions for streams, topics, partitions, segments, and message handling from this location, indicating a structural refactor or migration to a different module or implementation.

streaming · high confidence

Rust SDK refactoring and diagnostic event types

The Rust SDK has been restructured into smaller packages, moving core types to the common module. This change introduces a new \DiagnosticEvent\ enum to track client lifecycle states (shutdown, disconnected, connected, signed\_in, signed\_out) and relocates \ClientInfo\ types. Additionally, the \ConsumerGroupInfo\ struct now uses \group\_id\ instead of \consumer\_group\_id\ for the consumer group identifier.

core/common/src/types/client, core/common/src/types/diagnostic · high confidence

Unified transport protocol configuration with flexible serialization

The configuration module now centralizes transport protocol definitions in a new \TransportProtocol\ enum, supporting TCP, QUIC, HTTP, and WebSocket. This change allows users to specify the transport protocol in configuration files using either human-readable strings (e.g., "tcp", "quic") or numeric codes (1–4), with custom serialization logic ensuring compatibility across JSON, TOML, and HTTP interfaces.

core/common/src/types/configuration · high confidence

User model refactoring and extensible options

The user type definitions have been reorganized into a dedicated module, introducing an extensible \options\ field to both \UserInfo\ and \UserInfoDetails\ that allows clients to store custom key-value data. The \IdentityInfo\ structure has been simplified to expose only the \access\_token\ directly, removing the nested \IdentityTokens\ wrapper. Additionally, the \created\_at\ timestamp is now represented by the \IggyTimestamp\ type instead of a raw \u64\, and error handling in \UserStatus\ has been updated to use the \IggyError\ type.

core/common/src/types/user · high confidence

Fixes

Logging now respects configuration for retention, level, path, and file output

The server's logging subsystem has been rewritten to properly honor the \retention\, \level\, \path\, and \file\_enabled\ settings from the configuration. Previously, these options were ignored or handled incorrectly; now, log levels are strictly validated (rejecting typos like 'inof' and mapping 'none' to 'off'), file logging respects the specified path and rotation settings, and the system supports dynamic reloading of filters and output targets. This ensures that users can reliably control log verbosity, storage location, and retention policies via the server configuration.

_core/server\common/src/log · high confidence

Test coverage

1 commit adding/updating tests in core/sdk/tests; 11 commits adding/updating tests in bdd/rust/tests; 5 commits adding/updating tests in examples/java/src/test; 6 commits adding/updating tests in core/simulator; Add PHP BDD test environment and configuration; Added Go BDD test suite for messaging, clustering, and raw commands; Added Java BDD tests for basic messaging and stream lifecycle; Added Python BDD test suite for basic messaging and raw commands; Added tests for module graph integrity and server bootstrap; Go SDK BDD test coverage for consumer groups, offsets, and partitions; Java BDD test suite with Gradle wrapper and environment-driven configuration; New Rust BDD test suite for cluster, messaging, and resource management; PHP BDD test suite wiring and scenario coverage.

Dependencies

Initial Cargo.lock generation for Rust dependencies

The project now includes a generated \Cargo.lock\ file, which pins the exact versions of all Rust dependencies and their transitive sub-dependencies. This ensures reproducible builds across different environments and prevents unexpected version drift during development and release.

(dependencies) · high confidence

Python BDD environment migrates to uv and pins Python 3.10

The Python BDD test environment now uses the \uv\ package manager for dependency resolution and installation, replacing the previous tooling. The environment is explicitly pinned to Python 3.10 via a new \.python-version\ file, and the Dockerfile has been updated to install \uv\ and use it for syncing dependencies. A new \pylock.toml\ file provides a deterministic, hashed lockfile for all Python dependencies, ensuring reproducible test runs.

bdd/python · 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 56 → 58 (+2.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 77 → 80 (+3.5)
  • Architecture 98 → 98 (-0.4)
  • Maturity 83 → 92 (+8.5)
  • Readiness 47 → 61 (+14.1)
  • Security 47 → 46 (-0.8)
  • Event Sourcing 100 → 100 (+0.0)
  • Performance 70 → 60 (-9.7)

Resolved (545)

  • AvroStreamEncoder::serde_json_to_avro_value (cyclomatic 19) (core/connectors/sdk/src/encoders/avro.rs)
  • BinaryMapper.MapRentedMessages (cognitive 25) (foreign/csharp/Iggy_SDK/Mappers/BinaryMapper.cs)
  • Change coupling: metrics.rs ↔ lib.rs (core/shard/src/metrics.rs)
  • ClassTooLong: HttpSink (core/connectors/sinks/http_sink/src/lib.rs)
  • ClassTooLong: IggyConsumer (core/sdk/src/clients/consumer.rs)
  • ClassTooLong: LocalConnectorsConfigProvider (core/connectors/runtime/src/configs/connectors/local_provider.rs)
  • ClassTooLong: MeilisearchSink (core/connectors/sinks/meilisearch_sink/src/lib.rs)
  • ClassTooLong: PartitionPersistence (core/partitions/src/persistence.rs)
  • ClassTooLong: PostgresSource (core/connectors/sources/postgres_source/src/lib.rs)
  • ClassTooLong: ProtoConvert (core/connectors/sdk/src/transforms/proto_convert.rs)
  • ClassTooLong: ProtoStreamEncoder (core/connectors/sdk/src/encoders/proto.rs)
  • ClassTooLong: RedshiftSink (core/connectors/sinks/redshift_sink/src/lib.rs)
  • ClassTooLong: SurrealDbSink (core/connectors/sinks/surrealdb_sink/src/lib.rs)
  • ClassTooLong: Worker (core/sdk/src/clients/consumer/deferred.rs)
  • ClickHouseClient::insert (cognitive 18) (core/connectors/sinks/clickhouse_sink/src/client.rs)
  • ClickHouseSink::open (cognitive 16) (core/connectors/sinks/clickhouse_sink/src/sink.rs)
  • ClientCore.exchange (cognitive 90) (foreign/swift/Sources/Iggy/Client/ClientCore.swift)
  • ClientCore.exchange (cyclomatic 37) (foreign/swift/Sources/Iggy/Client/ClientCore.swift)
  • ConsumerGroupLiveness::receive (cyclomatic 16) (core/server/src/consumer_group/lease.rs)
  • Dead code: ErrorFactory (foreign/csharp/Iggy_SDK/Errors/ErrorFactory.cs)
  • …and 525 more

New (982)

  • BinaryMapper.MapRentedRecords (cognitive 25) (foreign/csharp/Iggy_SDK/Mappers/BinaryMapper.cs)
  • Change coupling: bounds_guard.rs ↔ mod.rs (core/kafka_wire/src/bounds_guard.rs)
  • Change coupling: lib.rs ↔ deps.rs (core/shard/src/lib.rs)
  • ClassTooLong: Coordination (gateways/kafka/src/coordinator/mod.rs)
  • ClassTooLong: DiskReadPlan (core/partitions/src/poll_plan.rs)
  • ClassTooLong: MessagesTcpClient (foreign/java/java-sdk/src/main/java/org/apache/iggy/client/async/tcp/MessagesTcpClient.java)
  • ClassTooLong: PartitionLog (gateways/kafka/src/coordinator/partition.rs)
  • ClassTooLong: PartitionReader (foreign/go/client/reader/reader.go)
  • ClassTooLong: PartitionReader (foreign/java/java-sdk/src/main/java/org/apache/iggy/client/async/reader/PartitionReader.java)
  • ClassTooLong: PartitionReader (foreign/node/src/stream/partition-reader.ts)
  • ClassTooLong: Progress (core/sdk/src/clients/reader/progress.rs)
  • ClassTooLong: Responses (foreign/swift/Sources/Iggy/Protocol/Responses.swift)
  • ClassTooLong: Worker (core/sdk/src/clients/reader/worker.rs)
  • ClassTooLong: replicaLinks (foreign/go/client/tcp/tcp_replicas.go)
  • ClientCore.exchangeWithCommit (cognitive 90) (foreign/swift/Sources/Iggy/Client/ClientCore.swift)
  • ClientCore.exchangeWithCommit (cyclomatic 37) (foreign/swift/Sources/Iggy/Client/ClientCore.swift)
  • CommandResponseStream.routesOf (cognitive 19) (foreign/node/src/client/client.socket.ts)
  • ConnectionString.parseOptions (cognitive 16) (foreign/swift/Sources/Iggy/Client/ConnectionString.swift)
  • ConnectionString.parseOptions (cyclomatic 19) (foreign/swift/Sources/Iggy/Client/ConnectionString.swift)
  • ConsumerGroup::rebalance_members (cognitive 16) (core/metadata/src/stm/consumer_group.rs)
  • …and 962 more

Changes since last survey

  • 131 commits — 98 feature/other, 33 fixes

By area

  • core/partitions — 18 commits
  • gateways/kafka — 17 commits
  • core/connectors — 9 commits
  • core/server — 8 commits
  • core/integration — 7 commits
  • examples/python — 6 commits
  • foreign/cpp — 5 commits
  • foreign/csharp — 4 commits
  • foreign/go — 4 commits
  • foreign/java — 4 commits
  • foreign/node — 4 commits
  • web/package-lock.json — 4 commits
  • (root) — 3 commits
  • .github/workflows — 3 commits
  • bdd/java — 3 commits
  • core/journal — 3 commits
  • core/ai — 2 commits
  • core/cli — 2 commits
  • core/object_store — 2 commits
  • core/simulator — 2 commits

Notable commits

  • fix: chore(repo): fix image revision label, move test-only deps to dev-deps (#4808)
  • fix: fix(ci): prevent false Python example passes (#4762)
  • fix: fix(ci): stop Markdown lint hanging on a Node 23 download (#4669)
  • fix: fix(cluster)!: let slow replicas catch up under load (#4658)
  • fix: fix(cluster,sdk)!: prevent partition stalls and lost reader batches (#4868)
  • fix: fix(common): reject malformed user headers during deserialization (#4670)
  • fix: fix(configs): reject clusters exceeding VSR replica limit (#4661)
  • fix: fix(connectors): address Iceberg sink issues batch (#4736)
  • fix: fix(connectors): reject ambiguous proto field mappings (#4581)
  • fix: fix(connectors): retry failed Iceberg catalog commits (#4740)
  • fix: fix(connectors): skip Iceberg rows that do not match the table schema (#4739)
  • fix: fix(connectors): tighten Iceberg sink redelivery skip and error mapping (#4775)
  • fix: fix(gateways): keep Kafka Fetch answering when one partition stalls (#4706)
  • fix: fix(gateways): stop Kafka Produce sends at the request deadline (#4643)
  • fix: fix(gateways): survive Kafka accept errors and a late Iggy at startup (#4645)
  • fix: fix(go): validate personal access token name length (#4763)
  • fix: fix(integration): avoid rejoin race in segment deletion test (#4687)
  • fix: fix(journal): unlink every rolled .log above a rewound WAL tail (#4816)
  • fix: fix(mcp): document allowed values for poll strategy and partitioning (#4588)
  • fix: fix(mcp): harden MCP server defaults and tool behavior (#4896)
  • …and 111 more

Architecture

  • Containers 0 added · 0 removed · contexts 0 added · 1 removed · edges 0 added · 1 removed

Removed bounded contexts (1)

  • iggy-connector-pinot

Removed dependency edges (was a dependency, now gone) (1)

  • iggy-connector-pinot → java-sdk

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/iggy 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 14 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 66f5adcdc7e4ebbe9bce9185bbc98b4a6ca80492 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — 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.65+preprod-e1a3b69fc8ee.