buildersoftio/andyx

Andy X is a distributed messaging platform that manages the lifecycle of tenants, products, components, topics, and subscriptions through a comprehensive REST API. It facilitates real-time message delivery to consumers and handles producer connections via WebSocket hubs, while maintaining cluster state synchronization across nodes. The system persists configuration and message data to local storage and supports distributed clustering with configurable shard distribution.

20 changes.

This period focused on modernizing the application's infrastructure by introducing Docker support and upgrading to .NET 7. Significant effort was dedicated to building the core domain models for tenants, products, components, and topics, alongside implementing the distributed cluster synchronization and hub abstractions required for multi-node operation.

22 changes.

This period focused on exposing a comprehensive REST API for managing core resources and implementing the foundational models and services for distributed cluster communication. The work introduced new entity models, in-memory repositories, and hub services to handle node connections, event broadcasting, and subscription routing across the cluster.

A new ConsumerHub class has been added to manage the lifecycle of consumer connections. It handles connection initialization, validates tenant, product, and component authorization tokens, and manages subscription registration. This introduces the core infrastructure for consumers to connect and receive messages via the router's hub system.

src/Andy.X.Router/Hubs/Consumers · high confidence

The application now exposes a comprehensive set of REST API endpoints under the /api/v3/ route prefix, enabling programmatic management of core resources. Users can now create, read, update, and delete tenants, products, components, topics, producers, and subscriptions via dedicated controllers (TenantsController, ProductsController, ComponentsController, TopicsController, ProducersController, SubscriptionsController). Additionally, new endpoints allow querying cluster nodes, retrieving activity counts for all major entities, and fetching active subscription/producer lists. All endpoints require admin or readonly role authorization, ensuring secure access to administrative operations.

src/Andy.X.App/Controllers · high confidence

A new SubscriptionHubService class has been introduced to manage the delivery of messages to connected consumers. The service handles both unique and shared subscription types, ensuring that messages are transmitted to the appropriate consumer connections via the SignalR hub context.

src/Andy.X.Router/Services/Subscriptions · high confidence

The utility library now includes new helper classes for security operations. CryptographyExtensions provides a ToHashString method that generates a SHA-512 hash of a string with an optional salt. KeyGenerators provides a method to generate a random 64-byte API secret encoded in Base64. These additions support the implementation of an authorization store with hashed secrets.

src/Andy.X.Utility/Generators · high confidence

A new ClusterChangeLog entity has been introduced to track cluster changes, including fields for entry, tenant, product, component, topic, headers, ID, payload, and sent date. This supports the implementation of distributed async clustering by providing a structured model for change log entries.

src/Andy.X.Model/Entities/Clusters · medium confidence

A new ClusterHub class has been introduced in the router to handle the lifecycle of distributed cluster nodes. It registers nodes upon connection, validates headers for node ID, cluster ID, and shard ID, and manages the state of connected replicas. On disconnect, it cleans up node references and stops outbound message services, ensuring proper cleanup of cluster topology.

src/Andy.X.Router/Hubs/Clusters · medium confidence

A new ClusterHubRepository class has been introduced to manage the lifecycle of node clients within a cluster. This repository maintains a concurrent dictionary of active node connections, allowing the system to track which nodes are currently connected or disconnected. It provides methods to add, remove, and retrieve node clients by connection ID or node ID, and updates the connection status of replicas in the underlying cluster repository when nodes connect or disconnect.

src/Andy.X.Router/Repositories/Clusters · high confidence

A new JsonExtensions class was added to the Andy.X.Utility library, providing helper methods for converting objects to and from JSON strings. Specifically, it adds a JsonToObject method to deserialize JSON into a specified class, and ToPrettyJson and ToJson methods to serialize objects into formatted or compact JSON strings using the Newtonsoft.Json library.

src/Andy.X.Utility/Extensions/Json · high confidence

A new static class, TenantIOReader, was added to the Readers directory. It provides a method, ReadTenantsFromConfigFile, which reads tenant configurations from a file located via ConfigurationLocations. The implementation includes a retry loop that sleeps for 100ms on failure, ensuring robust access to the configuration file.

src/Andy.X.IO/Readers · high confidence

A new TenantIOWriter class has been introduced in the IO layer to handle the serialization and file-based storage of system configurations. This component provides static methods to persist tenant, storage, transport, and cluster configurations as JSON files, enabling the system to manage its own state on disk.

src/Andy.X.IO/Writers · high confidence

A new BasicAuthenticationHandler has been introduced to enforce basic authorization on REST endpoints. This handler validates incoming requests against configured credentials and assigns user roles, enabling secure access to the API.

src/Andy.X.App/Handlers · high confidence

New event argument classes have been added to the \Andy.X.Model\ layer to support distributed cluster operations. These include \ComponentEvents\, \ConsumerEvents\, \NodeEvents\, \ProducerEvents\, \ProductEvents\, \SubscriptionEvents\, \TenantEvents\, and \TopicEvents\. Each file defines specific argument classes (e.g., \ComponentCreatedArgs\, \NodeConnectedArgs\) that carry metadata such as tenant, product, component, and state information, enabling the system to track and process cluster-related lifecycle events.

src/Andy.X.Model/Clusters/Events · high confidence

A new LoggerSink class has been introduced in the Synchronizers utility to enable writing logs to a specified file path. This change allows the Synchronizers component to persist log output to disk, supplementing the existing console tracing with file-based auditing.

src/Andy.X.Utility/Synchronizers · high confidence

A new in-memory implementation of the subscription hub repository has been added to manage subscription states and connected consumers. This component maintains a concurrent dictionary of subscriptions, allowing for the addition and removal of both internal and external consumers, as well as querying subscription activities and positions. The implementation initializes subscription positions based on the configured initial position (earliest or latest) and ensures the underlying database context is created.

src/Andy.X.Router/Repositories/Subscriptions · high confidence

A new Component class has been added to the application model, providing a structure to manage a collection of Topics and associated ComponentSettings. This introduces a new entity for representing components within the system, each capable of holding a dictionary of topics and configuration settings.

src/Andy.X.Model/App/Components · high confidence

A new Consumer model has been added to represent a client connection, containing properties for subscription, unique identifier, name, and connection details such as client and server IP addresses. This model serves as the foundational data structure for tracking active consumer instances and their network endpoints.

src/Andy.X.Model/Consumers · high confidence

Users can now build and run Andy X as a Docker container using a new Dockerfile that targets the .NET 7 runtime. The application's startup configuration has been updated to map environment variables (such as ANDYX\_ENVIRONMENT and ANDYX\_URLS) to ASP.NET Core settings, and the entry point is configured to run the application via the Docker image.

src/Andy.X.App · high confidence

A new OrchestratorService has been added to the router's orchestrator layer. This service acts as a central registry for topic and subscription data services, managing concurrent dictionaries for read/write and read-only access to topic data, unacknowledged messages, and cluster change logs. It initializes and retrieves specific data service implementations (such as TopicRocksDbDataService and ClusterRocksDbDataService) based on tenant, product, component, and topic identifiers, effectively abstracting the creation and lookup of these data access components.

src/Andy.X.Router/Services/Orchestrators · high confidence

A new repository class, ProducerHubRepository, has been added to handle the lifecycle of producer connections. It maintains an in-memory store of active producers, allowing the system to add, retrieve, and remove producer instances by connection ID or by filtering on tenant, product, component, and topic. It also aggregates producer activity metrics, enabling the platform to track the status and count of active producer instances.

src/Andy.X.Router/Repositories/Producers · high confidence

A new ProducerHubService class has been added to the router's producer services. It implements IProducerHubService and provides methods to notify about producer message arrival, failure, and sending status. The implementation currently throws NotImplementedException, indicating it is a structural addition awaiting full logic implementation.

src/Andy.X.Router/Services/Producers · medium confidence

A new Product model class has been added to the application, defining a product entity with a name, description, and a concurrent dictionary of components. This change establishes the data structure for managing product information and its associated components within the application's model layer.

src/Andy.X.Model/App/Products · high confidence

Added new domain models for topic management: a \Topic\ class representing a topic's name, description, and state, and a \TopicStates\ class tracking the latest entry ID and mark-delete position. This establishes the core data structures for topic configuration and state tracking within the application.

src/Andy.X.Model/App/Topics · high confidence

The system now uses dedicated static helper classes to resolve file and directory paths for tenants, producers, and cluster nodes. A new \ConfigurationLocations\ class defines paths for active and initial configuration files (e.g., \tenants.json\, \storage\_config.json\), logging directories, and temporary storage roots. \TenantLocations\ provides a hierarchical path structure for tenants, products, components, topics, subscriptions, and consumers, including specific directories for logs, tokens, and unacknowledged messages. \ClusterLocations\ and \ProducerLocations\ similarly abstract paths for cluster state, message directories, and producer-specific logs. This change standardizes how the application locates and organizes its data, logs, and configuration files on the filesystem.

src/Andy.X.IO/Locations · high confidence

The system now defines the fundamental data structures for message handling. A new \Message\ class encapsulates message metadata including tenant, product, component, topic, headers, and payload, alongside a \MessageAcknowledgement\ enum to track delivery status. Additionally, a \MessageAcknowledgementFileContent\ class is introduced to persist acknowledgement state for subscriptions, enabling the system to track which messages have been processed or skipped.

src/Andy.X.Model/App/Messages · high confidence

Added new domain models for managing subscriptions and their associated activities. The \Subscription\ class now tracks tenant, product, component, and topic details, along with subscription type (Unique, Failover, Shared), mode (Resilient/NonResilient), and initial position (Earliest/Latest). It also maintains concurrent dictionaries of connected consumers and external consumers, alongside a database context for position tracking. Additionally, a \SubscriptionActivity\ class was introduced to track the name, location, and active status of subscription activities.

src/Andy.X.Model/Subscriptions · high confidence

Added the Tenant class to represent a tenant's identity, including a collection of products and tenant-specific settings. Additionally, introduced a TenantLogging enum to define logging severity levels (ALL, INFORMATION\_ONLY, WARNING\_ONLY, ERROR\_ONLY) for tenant-level operations.

src/Andy.X.Model/App/Tenants · medium confidence

A new ProducerHub class has been added to handle the lifecycle of producer connections. It validates tenant, product, and component authorization tokens via HTTP headers, enforces unique producer names for single-instance producers, and supports automatic creation of tenants, products, components, and topics based on specific settings (e.g., IsTopicAutomaticCreationAllowed).

src/Andy.X.Router/Hubs/Producers · high confidence

The core library now includes a comprehensive set of interfaces and implementations to support distributed clustering and real-time communication. New abstractions for cluster hubs (IClusterHub, IConsumerHub, IProducerHub) and cluster services (IClusterHubService, IDistributedAsyncClusterService, IDistributedSyncClusterService) enable nodes to synchronize metadata and state across the cluster. The NodeConnectionProvider establishes secure (SSL/TLS) or non-secure connections between cluster nodes using SignalR, while event handlers (e.g., ComponentEventHandler) process cluster-wide events to keep local state consistent with the cluster's current state.

src/Andy.X.Core · high confidence

Added new event models to track consumer connectivity and message delivery details. ConsumerConnectedDetails and ConsumerDisconnectedDetails now capture tenant, product, component, topic, subscription, and connection identifiers to monitor consumer sessions. MessageSentDetails and MessageAcknowledgedDetails provide structured data for message delivery, including headers, message IDs, payloads, sent dates, and acknowledgement states.

src/Andy.X.Model/Consumers/Events · high confidence

Three new static service classes—ClusterIOService, MessageIOService, and TenantIOService—have been added to the IO layer. These services handle the creation of hierarchical directory structures for tenants, products, components, topics, subscriptions, and consumers, as well as the serialization and deserialization of message and acknowledgement data using MessagePack. This introduces new capabilities for managing local storage paths and persisting message data to temporary files.

src/Andy.X.IO/Services · medium confidence

Added new model classes to the system: ApplicationDetails in the App namespace, and Producer, ProducerActivity in the Producers namespace. These classes define the data structures for application metadata and producer configurations, including properties for tenant, product, component, topic, and activity status.

src/Andy.X.Model/Producers · medium confidence

Added three new event detail classes to the model layer: MessageAcceptedDetails, ProducerConnectedDetails, and ProducerDisconnectedDetails. These classes define the structure for tracking when a producer connects or disconnects from a topic, as well as the details of accepted messages, enabling the system to monitor producer lifecycle and message flow.

src/Andy.X.Model/Producers/Events · high confidence

Added five new entity classes to the storage layer: AcknowledgedMessage, Message, SkippedMessage, TopicEntryPosition, and UnacknowledgedMessage. These models define the data structures used to track message states, headers, payloads, and entry positions within the distributed sync cluster.

src/Andy.X.Model/Entities/Storages · high confidence

Added ConnectorHelper to generate and parse structured keys for tenants, products, components, topics, and subscriptions, and added MessagePackExtensions to serialize and deserialize objects using MessagePack.

src/Andy.X.Utility/Extensions/Helpers · medium confidence

A new \ClusterHubService\ has been introduced in the router's cluster services to handle the broadcasting of cluster-wide events (such as tenant, product, component, and subscription lifecycle changes) to all connected nodes via SignalR. This service acts as the central dispatcher for cluster synchronization, ensuring that all nodes in the distributed system are notified of metadata changes and connection states.

src/Andy.X.Router/Services/Clusters · high confidence

A new SubscriptionPosition entity has been introduced to track subscription state, including properties for read and delete entry positions, connection status, and timestamps. This supports the implementation of unique message consumption and RocksDB-based storage for subscriptions.

src/Andy.X.Model/Entities/Subscriptions · medium confidence

The application's startup process now explicitly registers and wires up the core infrastructure services through dedicated extension methods. This includes configuring the application, cluster, configuration, consumer, producer, and tenant state services, as well as setting up logging with Serilog and initializing core repositories. This change consolidates the service registration logic, ensuring that all essential components like the InboundMessageService, OutboundMessageService, and various repositories are properly initialized at startup.

src/Andy.X.App/Extensions/DependencyInjection · high confidence

The system now supports distributed clustering with configurable shard distribution types (Async or Sync) and replica management. Users can define cluster configurations including throughput metrics, shard states, and replica types (Main, Worker, BackupReplica) to manage data distribution across nodes.

src/Andy.X.Model/Clusters · high confidence

The system introduces a new set of configuration classes to manage runtime and infrastructure settings. These include ClusterConfiguration for shard distribution and node identity, StorageConfiguration for tuning write buffers, background threads, and retention intervals, TenantConfiguration for organizing tenants, products, components, and subscriptions, ThreadsConfiguration for thread pool limits, TransportConfiguration for client timeouts, keep-alive intervals, and message size limits, and CredentialsConfiguration for authentication details. These models provide the structural foundation for configuring the application's behavior and performance characteristics.

src/Andy.X.Model/Configurations · high confidence

Added new C\# entity classes for the core domain, including Component, Product, Tenant, Topic, and Subscription, along with their associated settings, retention, and token models. This introduces the data structures required to support the new REST endpoints for these resources.

src/Andy.X.Model/Entities/Core · high confidence

The solution file (Buildersoft.Andy.X.sln) now references the renamed Andy.X.IO project and the new src directory structure. The README has been updated with a new logo, a corrected getting started link, an updated security reporting email, and links to the new Andy X Portal and CLI repositories.

(repo-wide) · high confidence

The project files have been updated to target .NET 7.0, with several libraries upgraded to their .NET 7 compatible versions (e.g., Microsoft.AspNetCore.SignalR.Client 7.0.0, Microsoft.Extensions.\* 7.0.0). Additionally, the RocksDB package was updated to version 7.7.3.33461, and Serilog packages were added to the application project.

(dependencies) · medium confidence

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

• CAI 33 → 29 (-4.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 38 → 25 (-13.3)
• Architecture 75 → 76 (+0.2)
• Maturity 41 → 41 (-0.0)
• Readiness 18 → 18 (+0.0)
• Security 77 → 60 (-17.4)
• Performance 60 → 60 (+0.0)

• Boundary-crossing change coupling: TenantsController.cs ↔ CoreRepository.cs (src/Andy.X.App/Controllers/TenantsController.cs)
• Bounded contexts not declared
• Change coupling: ComponentsController.cs ↔ ProductsController.cs (src/Andy.X.App/Controllers/ComponentsController.cs)
• Change coupling: ComponentsController.cs ↔ TenantsController.cs (src/Andy.X.App/Controllers/ComponentsController.cs)
• Change coupling: ComponentsController.cs ↔ TopicsController.cs (src/Andy.X.App/Controllers/ComponentsController.cs)
• Change coupling: CoreRepository.cs ↔ CoreService.cs (src/Andy.X.Core/Repositories/CoreState/CoreRepository.cs)
• Change coupling: ITenantStateService.cs ↔ TenantFactory.cs (src/Andy.X.Core/Abstractions/Services/ITenantStateService.cs)
• Change coupling: ProductsController.cs ↔ TenantsController.cs (src/Andy.X.App/Controllers/ProductsController.cs)
• Change coupling: ProductsController.cs ↔ TopicsController.cs (src/Andy.X.App/Controllers/ProductsController.cs)
• Change coupling: TenantFactory.cs ↔ TenantStateService.cs (src/Andy.X.Core/Factories/Tenants/TenantFactory.cs)
• Duplicated block (10 lines × 2) (src/Andy.X.App/Controllers/ComponentsController.cs)
• Duplicated block (10 lines × 2) (src/Andy.X.App/Controllers/ProducersController.cs)
• Duplicated block (10 lines × 3) (src/Andy.X.App/Controllers/ProducersController.cs)
• Duplicated block (12 lines × 2) (src/Andy.X.Core/Services/CoreState/CoreService.cs)
• Duplicated block (12 lines × 2) (src/Andy.X.Core/Services/CoreState/CoreService.cs)
• Duplicated block (13 lines × 2) (src/Andy.X.Core/Services/CoreState/CoreService.cs)
• Duplicated block (13 lines × 2) (src/Andy.X.Router/Hubs/Consumers/ConsumerHub.cs)
• Duplicated block (14 lines × 2) (src/Andy.X.Core/Services/Outbound/OutboundMessageService.cs)
• Duplicated block (22 lines × 2) (src/Andy.X.Core/Services/Data/SubscriptionUnackedDataService.cs)
• Duplicated block (6 lines × 2) (src/Andy.X.Router/Hubs/Consumers/ConsumerHub.cs)
• …and 20 more

• Change coupling: InboundMessageService.cs ↔ OutboundMessageService.cs (src/Andy.X.Core/Services/Inbound/InboundMessageService.cs)
• Change coupling: TenantStateService.cs ↔ InboundMessageService.cs (src/Andy.X.Core/Services/App/TenantStateService.cs)
• CommentedOutCode (src/Andy.X.App/Extensions/DependencyInjection/LoggingDependencyInjectionExtensions.cs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (src/Andy.X.Core/Services/App/TenantStateService.cs)
• Duplicated block (10 lines × 2) (src/Andy.X.Model/Entities/Core/Components/Component.cs)
• Duplicated block (10 lines × 2) (src/Andy.X.Model/Entities/Core/Products/ProductToken.cs)
• Duplicated block (10 lines × 21) (src/Andy.X.Core/Services/CoreState/CoreService.cs)
• Duplicated block (10 lines × 3) (src/Andy.X.Model/Clusters/Events/SubscriptionEvents.cs)
• Duplicated block (10 lines × 40) (src/Andy.X.App/Controllers/ComponentsController.cs)
• Duplicated block (12 lines × 3) (src/Andy.X.App/Controllers/ProductsController.cs)
• Duplicated block (12 lines × 5) (src/Andy.X.Model/App/Messages/MessageAcknowledgementFileContent.cs)
• Duplicated block (12–14 lines × 5) (src/Andy.X.Core/Services/CoreState/CoreService.cs)
• Duplicated block (13 lines × 2) (src/Andy.X.Core/Services/CoreState/CoreService.cs)
• Duplicated block (13 lines × 2) (src/Andy.X.Core/Services/CoreState/CoreService.cs)
• Duplicated block (13 lines × 2) (src/Andy.X.Model/App/Messages/MessageAcknowledgementFileContent.cs)
• Duplicated block (13 lines × 8) (src/Andy.X.Core/Services/CoreState/CoreService.cs)
• Duplicated block (14 lines × 2) (src/Andy.X.App/Controllers/ComponentsController.cs)
• Duplicated block (14–15 lines × 3) (src/Andy.X.Model/Entities/Core/Components/ComponentRetention.cs)
• …and 110 more

• Unchanged — 73 HTTP endpoints

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

buildersoftio/andyx 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.