vip32/Naos

This system is a comprehensive .NET application framework designed to accelerate the development of distributed, event-driven microservices. It provides foundational infrastructure for Domain-Driven Design, including event sourcing, generic repositories, and a command handling pipeline that supports both synchronous execution and asynchronous queue-based processing. The platform also integrates essential operational capabilities such as structured logging, distributed tracing, multi-tenant data isolation, and flexible messaging via various brokers like RabbitMQ and Azure Service Bus.

206 changes.

This period established the core platform by initializing the .NET solution, defining foundational DDD domain models, and implementing cross-cutting infrastructure for messaging, file storage, and key-value persistence. It also introduced comprehensive unit and integration test suites to validate these new components and ensure architectural fitness.

31 changes.

This period focused on establishing core event sourcing abstractions, including aggregate roots, repositories, and storage backends like EventStore and in-memory stores. It also expanded the platform's infrastructure by implementing document and queueing providers for SQLite, SQL Server, RabbitMQ, and Azure, alongside comprehensive architecture fitness tests to enforce domain-driven design principles.

A new repository class, LogAnalyticsLogEventRepository, has been introduced in the Azure infrastructure layer to handle log event persistence via Azure Log Analytics. This class implements ILogEventRepository and inherits from the generic LogAnalyticsRepository, allowing users to store and retrieve structured log events using the configured Azure credentials and HTTP client.

src/Operations.Infrastructure.Azure/Logging · high confidence

A new MessageStatus enum has been introduced in the messaging domain model to explicitly track the state of messages. It defines three distinct statuses: NotPublished, Published, and PublishedFailed, allowing consumers to determine whether a message has been successfully sent or if the publication process encountered an error.

src/Messaging/Domain/Model · high confidence

The application now supports two new messaging broker backends: Azure SignalR Serverless and File Storage. Users can enable the SignalR broker via the 'naos:messaging:signalr' configuration section, which registers a scoped 'IMessageBroker' using 'SignalRServerlessMessageBroker' with support for logging, tracing, MediatR integration, and subscription filtering. Similarly, the File Storage broker can be enabled via 'naos:messaging:fileStorage', registering a 'FileStorageMessageBroker' that persists messages to a configurable folder (defaulting to the system temp path) using JSON serialization, with support for processing delays and subscription filtering. Both brokers are registered as scoped services and allow for custom broker configuration via an optional action delegate.

src/Messaging.Application.Azure.SignalR · high confidence

A new console command \startuptasks\ has been added to allow users to list all registered startup tasks. Executing this command with the \-l\ (or \--list\) flag displays the names of all tasks currently registered in the system, sorted alphabetically, aiding in debugging and verification of the startup configuration.

src/Foundation.Application.Web.Startup/Console · high confidence

A new console command 'queueing' is now available, allowing users to trigger an echo item processing workflow. When the --echo flag is provided, the command enqueues five sample items and processes them through an in-memory queue, providing immediate feedback on queueing functionality.

src/Queueing.Application/Console · high confidence

A new 'traces' console command has been added to the application, allowing users to display trace information via the CLI. The command supports a '--recent' flag to show recent traces and a '--count' option to limit the number of results returned. When executed, it queries the log trace repository, filters for trace entries, and renders them in a hierarchical format showing message content, span IDs, duration, and timestamp.

src/Operations.Application/ConsoleCommands · high confidence

A new \ApplicationInsightsExporter\ class has been added to the Azure Tracing Infrastructure, implementing the \ISpanExporter\ interface to enable exporting tracing spans to Azure Application Insights. Currently, the \ExportAsync\ method is a placeholder that throws a \NotImplementedException\, indicating that the actual telemetry logic (such as tracking dependencies) is yet to be implemented.

src/Tracing.Infrastructure.Azure/ApplicationInsights · high confidence

Users can now configure the application to send trace logs to Azure Log Analytics. This is achieved by adding the \AddAzureLogAnalyticsTracing\ extension method, which registers a \LogAnalyticsLogTraceRepository\ implementation of \ILogTraceRepository\. The integration handles authentication via Azure AD using tenant ID, client ID, and client secret, and allows specifying a custom log name for the workspace.

src/Tracing.Infrastructure.Azure · high confidence

The \NaosExtensions.cs\ file in \src/Queueing.Application.Azure\ now provides extension methods to register Azure-based queueing providers. Users can configure either Azure Service Bus or Azure Storage Queues via \UseServiceBusQueue\ and \UseAzureStorageQueue\ respectively. These methods read configuration from \naos:queueing:serviceBus\ or \naos:queueing:azureStorageQueue\, register the corresponding \IQueue\<TData\>\ implementation (either \AzureServiceBusQueue\ or \AzureStorageQueue\) into the DI container, and add health checks for the respective queue. The registration supports optional expiration and retry settings.

src/Queueing.Application.Azure · high confidence

The application now supports Azure Service Bus as a message broker. A new extension method registers the necessary infrastructure, including a Service Bus provider, subscription client, and message handler, allowing the system to send and receive messages via Azure Service Bus topics and subscriptions.

src/Messaging.Application.Azure · high confidence

A new StorageQueueMessageBroker class has been introduced in the Azure messaging infrastructure to handle message routing via Azure Storage Queues. This component implements the IMessageBroker interface, accepting dependencies for logging, storage connection strings, handler factories, and subscription mapping. Currently, the Publish and Unsubscribe methods are marked as not implemented, while the Subscribe method returns the broker instance itself, indicating that the foundational structure for queue-based message consumption is in place but full publish/subscribe functionality is not yet complete.

src/Messaging.Infrastructure.Azure/Storage · high confidence

New extension methods are now available to configure command request storage and messaging backends. The Azure package adds support for storing command requests in Azure Blob Storage and sending them via Azure Storage Queue or Azure Service Bus Queue. The RabbitMQ package adds support for sending command requests via a RabbitMQ queue, allowing users to select their preferred infrastructure provider for command queuing.

src/Commands.Application.Web.Azure, src/Commands.Application.Web.RabbitMQ · high confidence

Introduced a set of configuration classes within the Foundation.Infrastructure.Azure module to define settings for various Azure services. These include AdAuthenticationConfiguration for tenant and client credentials, ApplicationInsightsConfiguration for monitoring, BlobStorageConfiguration and QueueStorageConfiguration for storage services, LogAnalyticsConfiguration for logging, and SignalRConfiguration for real-time communication. These models provide the structured data required to configure Azure integrations.

src/Foundation.Infrastructure.Azure · high confidence

This change introduces support for sending application logs to Azure services. It adds configuration classes and extension methods to enable logging to Azure Diagnostics Log Stream, Azure Blob Storage, and Azure Log Analytics. When Azure Log Analytics is enabled, it also registers the necessary repository to allow the dashboard to query these log events.

src/Operations.Infrastructure.Azure · high confidence

New data transfer objects have been introduced to model the structure of Azure Log Analytics query results. This includes \LogAnalyticsResponse\ to wrap the output, \LogAnalyticsTable\ to represent individual result tables with their columns and rows, and \LogAnalyticsColumn\ to define column metadata. A sample JSON file is also included to illustrate the expected data shape, aiding in development and validation of the repository layer.

src/Foundation.Infrastructure.Azure.LogAnalytics/Repositories/Dto · high confidence

New extension methods have been added to configure Entity Framework Core with SQL Server, SQLite, and In-Memory databases. These helpers simplify setup by reading connection strings from configuration or accepting them directly, and they enable detailed error logging and sensitive data logging by default to aid in development and debugging.

src/Foundation.Infrastructure.EntityFramework/Extensions · high confidence

A new EchoStartupTask has been introduced to the application startup sequence. This component implements the IStartupTask interface and logs a simple informational message ('hello from echo startup task') during the application's StartAsync phase, providing a basic verification point for the startup pipeline.

src/Foundation.Application.Web.Startup/Tasks · high confidence

The event sourcing infrastructure now includes a concrete \EventStoreEventStore\ implementation that persists domain events and aggregates to an EventStore database, supporting both event streaming and snapshotting via dedicated streams. A corresponding \SqlEventStore\ class has been added as a placeholder implementing the same \IEventStore\ interface, though its methods currently throw \NotImplementedException\.

src/Foundation.Infrastructure.EventStore · high confidence

A new middleware component has been introduced to automatically trace incoming HTTP requests. It creates distributed tracing spans for each request, capturing details such as HTTP method, URL, host, path, and response status code. The middleware supports configuration via options, allowing users to enable or disable tracing and define path patterns (e.g., static assets, Swagger, favicon) to exclude from tracing.

src/Tracing.Application.Web/Middleware · high confidence

A new JsonContent class has been introduced in the Client layer to simplify sending JSON payloads in HTTP requests. This class extends StringContent and automatically serializes objects to JSON using Newtonsoft.Json, providing a convenient alternative to external extension methods for POST operations.

src/Foundation.Application.Web/Client · high confidence

A new repository class, LogAnalyticsLogTraceRepository, has been introduced to persist trace information into Azure Log Analytics. This implementation maps specific trace properties—such as TrackId, OperationName, CorrelationId, SpanId, ParentSpanId, Kind, Status, StatusDescription, StartTime, and EndTime—to corresponding Log Analytics entity fields, enabling users to query and analyze detailed tracing data within their Log Analytics workspaces.

src/Tracing.Infrastructure.Azure/Repositories · high confidence

A new PathHelper class has been introduced in the FileStorage utility layer to standardize how file paths are processed. This utility provides methods to expand paths containing the \|DataDirectory\| placeholder by resolving them against the application's base directory, and to normalize path separators (forward vs. backslashes) to match the current operating system's conventions, ensuring consistent path handling across different environments.

src/FileStorage/Utility · high confidence

A new ResourcesHelper class has been introduced to provide convenient access to embedded resources within the Naos.Foundation assembly. This utility allows applications to retrieve the logo, favicon, and CSS stylesheets (including specific styles for Swagger UI) as either byte arrays, Bitmaps, or strings, simplifying the integration of these static assets into the application's UI and API documentation.

src/Foundation.Resources · high confidence

The \src/Tracing.Infrastructure.Zipkin\ package now includes the core components required to export distributed tracing spans to a Zipkin server. This introduces model classes (\ZipkinSpan\, \ZipkinEndpoint\, \ZipkinAnnotation\) to represent Zipkin protocol data, a \ZipkinSpanExporter\ implementation that maps internal spans to Zipkin format and sends them via HTTP POST, and a configuration class (\ZipkinSpanExporterConfiguration\) to enable/disable the exporter and specify the target host.

src/Tracing.Infrastructure.Zipkin · high confidence

The application now includes two new ASP.NET Core action filters in the Foundation layer. The NoCacheAttribute ensures that marked action methods do not cache their output by setting NoStore to true. The OperationCancelledExceptionFilterAttribute intercepts OperationCanceledException instances and returns a 499 Client Closed Request status code, logging the event when a client closes the TCP connection prematurely.

src/Foundation.Application.Web/Filters · high confidence

New configuration classes have been introduced to allow users to control logging behavior. ConsoleLoggingConfiguration enables or disables console output. FileLoggingConfiguration provides detailed settings for file-based logging, including the folder path (defaulting to the system temp directory with a 'naos\_operations' subfolder), file naming, output templates, size limits, rolling intervals, and write-sharing options. SeqLoggingConfiguration allows users to enable Seq logging and specify the endpoint URL and API key for sending logs to a Seq server.

src/Operations.Application/Configuration · high confidence

New domain event handlers have been introduced to process SpanStarted and SpanEnded events. SpanEndedExporterDomainEventHandler forwards completed spans to registered ISpanExporter implementations (such as Zipkin) for external storage. SpanEndedLogTraceDomainEventHandler maps span details (trace ID, span ID, status, timing) into structured log properties for correlation. SpanEndedLoggerDomainEventHandler provides human-readable debug and error logging for span lifecycle events, including duration and failure reasons. Additionally, the ILogTraceRepository interface has been added to support persistence of log traces.

src/Tracing.Domain/Events · high confidence

The system now includes a new \DomainEventMessagingPublisher\ abstract class that allows internal domain events to be automatically mapped and published as external messages via a message broker, enabling cross-service notifications. Additionally, a \TrackMessageDomainEventHandler\ has been introduced to log journal entries whenever messages are published or handled, providing visibility into message lifecycle events.

src/Messaging/Domain/Events · high confidence

The Foundation.Domain layer now includes four new exception types to improve error handling clarity: AggregateNotFoundException, EntityNotFoundException, InvalidAggregateIdException, and InvalidEntityIdException. These classes allow the application to distinguish between missing aggregates or entities and invalid identifier formats, providing more specific error information to callers.

src/Foundation.Domain/Exceptions · high confidence

Introduced the \NaosHealthReport\ and \NaosHealthReportEntry\ model classes to structure health check data. These models define the schema for reporting overall health status, duration, timestamps, and detailed entry information including tags and error descriptions, enabling the application to aggregate and expose health metrics.

src/Operations.Application/Model · high confidence

The FileStorage module now includes an in-memory implementation of the IFileStorage interface, allowing applications to store and retrieve files entirely in RAM without requiring persistent disk or cloud storage. This implementation supports standard file operations such as saving, reading, renaming, copying, and deleting files, along with bulk deletion via search patterns. It enforces configurable limits on maximum file size and total number of files, automatically evicting the oldest files when the count exceeds the threshold. Configuration is handled via InMemoryFileStorageOptions and an associated builder, allowing users to specify size limits, file count caps, and a custom serializer for file metadata.

src/FileStorage · high confidence

The application now includes infrastructure to process queue items automatically upon startup or as a background service. This is achieved by introducing \QueueProcessItemsStartupTask\ for one-time processing at launch and \QueueProcessItemsHostedService\ for continuous background processing, both accessible via new extension methods (\AddQueueProcessItemsStartupTask\ and \ProcessItemsHostedService\) on the service collection.

src/Queueing.Application.Web · high confidence

Introduced new application-layer components to support message queueing integration. This includes the \NaosExtensions\ class, which provides extension methods for registering queueing services via dependency injection, including automatic scanning for \QueueEventHandler\ implementations and configuring an in-memory queue provider. Additionally, \QueueingOptions\ and \QueueingProviderOptions\ classes were added to encapsulate configuration context for the queueing subsystem.

src/Queueing.Application · high confidence

Introduced two new decorator classes in the Queueing domain: AutoCompleteQueueDecorator and FileStorageQueueDecorator. The AutoCompleteQueueDecorator automatically marks queue items as complete immediately after they are dequeued, simplifying the consumption pattern for scenarios where manual completion is not required. The FileStorageQueueDecorator provides a placeholder for persisting enqueued items to file storage, though the underlying storage integration is currently commented out and not yet active.

src/Queueing/Domain/Decorators · high confidence

New middleware components have been introduced to the web application pipeline to enhance observability and debugging. The \RequestLoggingMiddleware\ captures detailed logs for inbound requests and responses, including HTTP method, URL, status codes, headers, and duration (formatted using Humanizer), while respecting configurable path blacklists. Additionally, the \RequestStorageMiddleware\ provides the capability to persist raw request and response bodies to a configured \IFileStorage\ implementation, enabling deeper inspection of traffic data. Both middlewares are controlled via dedicated options classes (\RequestLoggingMiddlewareOptions\ and \RequestStorageMiddlewareOptions\) that allow enabling/disabling the features and defining exclusion patterns.

src/Operations.Application.Web/Middleware · high confidence

Introduced a new \SystemMetricsClient\ in the \Naos.Foundation\ namespace that retrieves CPU load percentage and memory usage (total, used, free) for the host system. The client provides platform-specific implementations, using Windows Management Instrumentation (WMIC) commands on Windows and the \free\ command on Unix-like systems (Linux/macOS) to gather these metrics.

src/Foundation.Utilities/System · high confidence

The Foundation.Infrastructure.EntityFramework package now includes infrastructure to create DbContext instances on demand via dependency injection. This change introduces an IDbContextFactory interface and a concrete DbContextFactory implementation, along with a ServiceCollectionExtensions method (AddDbContextFactory) that registers these services. This allows applications to obtain fresh DbContext instances scoped to specific lifetimes, rather than relying on a single long-lived context.

src/Foundation.Infrastructure.EntityFramework · high confidence

The Tracing.Application layer now provides the core components for distributed tracing: an HttpClientDelegatingHandler that injects trace headers into outbound HTTP requests, a SpanViewModel for visualizing span hierarchies, and a fluent configuration API (OperationsOptionsExtensions) to register the tracer, select samplers, and configure span exporters via dependency injection.

src/Tracing.Application · high confidence

The Operations.Application.Web library now provides extension methods to integrate request logging and system health checks into the ASP.NET Core pipeline. Users can enable request logging and storage (supporting local folder or Azure Blob storage backends) via the UseOperationsLogging method, which captures request data and correlates it with diagnostics. Additionally, the UseOperationsHealth method exposes standard health endpoints (/health, /health/ready, /health/live) and registers system-level health checks for memory and CPU usage, allowing external monitoring systems to verify application status.

src/Operations.Application.Web · high confidence

A new behavior has been introduced that automatically persists incoming commands to the local file system. This component implements the chain-of-responsibility pattern to intercept command execution, serializing the request object into JSON files (defaulting to the pattern {id}-{type}.json) within a temporary journal directory. This ensures that all commands are logged for auditing or replay purposes without requiring explicit handling in individual command handlers.

src/Commands.Infrastructure.FileStorage/Domain/Handlers/Behaviors · high confidence

A new \TableKeyValueStorage\ implementation has been added to the \Naos.KeyValueStorage.Infrastructure.Azure\ package, providing a unified key-value storage backend for both Azure Table Storage and Azure Cosmos DB Table API. The provider automatically detects the backend based on the connection string (checking for \table.cosmos.azure.com\) and uses the \Microsoft.Azure.Cosmos.Table\ client library to handle operations such as insert, upsert, update, merge, and delete. Configuration is managed via \TableKeyValueStorageOptions\, allowing users to specify the connection string and the maximum batch insert limit (defaulting to 100).

src/KeyValueStorage.Infrastructure.Azure · high confidence

The Azure file storage infrastructure now includes implementations for Azure Blob Storage and Azure File Share, allowing users to store and retrieve files using these Azure services. The \AzureBlobFileStorage\ class provides full support for blob operations, while \AzureFileShareStorage\ handles file share operations, though renaming files in file shares is currently not implemented. Configuration options for both storage types are available via dedicated options classes and builders. An \AzureKeyVaultFileStorage\ class is also present as a placeholder, with all methods currently throwing \NotImplementedException\.

src/FileStorage.Infrastructure.Azure · high confidence

Users can now read and write CSV files directly through the file storage service using new extension methods. The \SaveFileCsvAsync\ methods allow saving data to CSV with configurable separators, culture settings, and date formats, while \GetFileCsvAsync\ retrieves and deserializes CSV content back into objects.

src/FileStorage.Csv · high confidence

A new console command (\browser\) has been added to the application, allowing users to launch the browser directly to specific operational dashboards. By passing flags such as \--logs\, \--traces\, \--journal\, or \--swagger\, the command automatically resolves the current server address and opens the corresponding URL (e.g., \/naos/operations/logevents/dashboard\ or \/swagger/index.html\) using the native OS browser handler.

src/Foundation.Application.Web/Console · high confidence

The FileStorage domain now includes a new \FileStorageExtensions\ class that provides helper methods for common file operations. Users can now easily save and retrieve strongly-typed objects (\SaveFileObjectAsync\, \GetFileObjectAsync\) using the storage's default or a specified serializer, read and write raw text contents (\SaveFileContentsAsync\, \GetFileContentsAsync\), retrieve raw byte arrays (\GetFileContentsRawAsync\), and manage file listings and deletions (\GetFileInformationsAsync\, \DeleteFilesAsync\). These extensions simplify interaction with the underlying \IFileStorage\ interface by handling serialization, stream management, and pagination logic.

src/FileStorage/Domain · high confidence

The application now supports seeding database entities at startup via a new generic \SeederStartupTask\. This feature allows developers to register specific entities to be inserted into the database during application initialization, ensuring required data (such as country lists) is present. The seeder checks for existing records to avoid duplicates and handles state initialization for entities implementing \IStateEntity\.

src/Foundation.Application.Web.Startup.Repositories · high confidence

This change introduces the core RabbitMQ infrastructure for the Naos messaging system, adding the \RabbitMQMessageBroker\ to handle message publishing and subscription binding, along with \RabbitMQProvider\ for resilient connection management and retry policies. It includes configuration options (\RabbitMQMessageBrokerOptions\) for defining exchange names, queue names, serialization, and message expiration, as well as a builder pattern for setup. The implementation supports direct exchanges with routing keys, persistent message delivery, correlation ID tracking, and distributed tracing headers.

src/Messaging.Infrastructure.RabbitMQ · high confidence

Added the core components for the Azure Service Bus foundation infrastructure, including configuration models, credential structures, and the provider implementation. This introduces \ServiceBusProvider\ which manages connections to Azure Service Bus namespaces, handles topic and subscription creation/verification, and provides topic clients, alongside supporting interfaces and configuration classes.

src/Foundation.Infrastructure.Azure.ServiceBus · high confidence

The Commands.Application layer now provides the core infrastructure for executing commands, including automatic registration of command handlers and behaviors via the Naos DI extension. It introduces sample commands (Echo, Ping, Test) with their respective handlers and validators to demonstrate usage, and defines constants for distributed tracing properties (TraceId, TraceSpanId, TraceSampled) to support observability.

src/Commands.Application · high confidence

This change introduces the core components for the SQL Server document storage provider within the \src/Foundation.Infrastructure.Documents.SqlServer\ module. It adds the \SqlServerDocumentProvider\ to handle document persistence and retrieval (including count, existence checks, and key/data loading) against a SQL Server database, utilizing \Dapper\ for data access. The implementation is supported by a new \SqlBuilder\ for generating SQL queries, \IndexMap\ classes for defining queryable indexes, and a fluent \SqlServerDocumentProviderOptionsBuilder\ for configuring connection strings, schemas, and index mappings.

src/Foundation.Infrastructure.Documents.SqlServer · high confidence

The repository is initialized with a comprehensive .NET solution structure and build tooling. This includes an .editorconfig enforcing C\# 8 coding conventions, a Directory.Build.props file setting up Roslyn 3.7.0, FxCop, and StyleCop analyzers, and GitVersion configuration for semantic versioning. CI/CD pipelines are defined in Azure Pipelines YAML files, and foundational documentation such as a Code of Conduct and Contributing guide are added.

(repo-wide) · high confidence

Added the \ServiceBusMessageBroker\ class and its associated configuration options (\ServiceBusMessageBrokerOptions\, \ServiceBusMessageBrokerOptionsBuilder\) to enable publishing and subscribing to Azure Service Bus topics. This implementation supports message serialization via \ISerializer\, distributed tracing context propagation (TraceId/SpanId) for observability, configurable retry policies, and subscription rule management.

src/Messaging.Infrastructure.Azure/ServiceBus · high confidence

Added a new \AzureServiceBusQueue\ implementation for the queueing infrastructure, enabling message persistence and processing via Azure Service Bus. This change introduces the core queue client (\AzureServiceBusQueue.cs\) along with its configuration options (\AzureServiceBusQueueOptions.cs\) and a fluent builder (\AzureServiceBusQueueOptionsBuilder.cs\), allowing users to configure connection strings, queue properties (such as TTL, dead-lettering, and partitioning), and retry policies.

src/Queueing.Infrastructure.Azure/ServiceBus · high confidence

Added a new Azure Storage Queue infrastructure component that implements the queueing domain interface using Microsoft Azure Storage Queues. This includes the core queue client for enqueuing, dequeuing, completing, and abandoning messages, along with support for dead-letter queues for failed items. The implementation integrates with Polly for retry policies, supports distributed tracing via correlation IDs, and provides metrics for queue depth and processing counts. Configuration is handled through a builder pattern allowing customization of connection strings, retry counts, processing intervals, and serialization.

src/Queueing.Infrastructure.Azure/Storage · high confidence

Added the core components for the Event Sourcing repository layer, including the \IEventStore\ interface and an \InMemoryEventStore\ implementation for reading and saving domain events. The change introduces supporting types such as \Event\<TId\>\ and \Snapshot\<TAggregate, TId\>\ wrappers, an \EventResult\ for version tracking, and specific exception classes (\EventStoreException\, \EventStoreStreamNotFoundException\, \EventStoreCommunicationException\). While the in-memory store currently implements event persistence and retrieval, snapshot read and save operations are present but not yet implemented.

src/Foundation.Domain.EventSourcing/Repositories/EventStore · high confidence

Added the EventSourcingRepository implementation and its corresponding interface, enabling the persistence and retrieval of event-sourced aggregates. This component handles reading events from the event store to reconstruct aggregate state, saving new domain events, and managing snapshots for optimized retrieval. It also includes a dedicated exception type for repository-level errors.

src/Foundation.Domain.EventSourcing/Repositories · high confidence

This change introduces two new foundation libraries. The \Foundation.ContentTypes\ library provides a comprehensive \ContentType\ enum mapping file extensions to MIME types, along with metadata attributes and extension methods to resolve content types from file names, extensions, or MIME values. The \Foundation.Criteria\ library introduces a \Criteria\ class and \CriteriaOperator\ enum to define filtering rules, supporting standard comparison operators (Equal, NotEqual, GreaterThan, etc.) and string functions (Contains, StartsWith, EndsWith), with extension methods to convert criteria into expression strings for querying.

src/Foundation.ContentTypes, src/Foundation.Criteria · high confidence

The application now includes a new \CommandRequestMiddleware\ that intercepts HTTP requests and routes them to command handlers via a configurable extension chain. This middleware supports both synchronous (Mediator) and asynchronous (Queue) dispatch strategies, allowing commands to be executed directly or enqueued for background processing. It automatically parses incoming requests from query strings or JSON bodies, injects correlation IDs, and propagates distributed tracing spans. The pipeline is extensible, featuring built-in logging and tracing extensions, and returns appropriate HTTP responses including command IDs and cancellation reasons.

src/Commands.Application.Web/Middleware · high confidence

The \src/Foundation.Infrastructure.Mongo\ package now provides a complete MongoDB persistence layer, including \MongoRepository\ implementations for both direct entity storage and mapped destination documents. This change adds configuration options (\MongoConfiguration\, \MongoRepositoryOptions\), a fluent options builder, and dependency injection extensions to register the MongoDB client with custom conventions and optional command logging. It also introduces LINQ extension methods (\WhereExpression\, \OrderByIf\, \SkipIf\, \TakeIf\) that enable specification-based filtering and conditional sorting/pagination on MongoDB queries, along with domain interfaces like \IMongoDocument\ to support the mapping layer.

src/Foundation.Infrastructure.Mongo · high confidence

Users can now access Naos FileStorage through the standard Microsoft.Extensions.FileProviders.IFileProvider interface. This change adds three new classes—FileStorageProvider, FileStorageFileInfo, and FileStorageDirectoryContents—which wrap the existing IFileStorage service to provide file information and directory listing capabilities compatible with ASP.NET Core file provider expectations.

src/FileStorage/Provider · high confidence

Adds a new SQLite-based implementation for the document repository infrastructure, including the SqliteDocumentProvider, SqliteBuilder, and associated options and builders. This allows applications to persist document entities to a SQLite database, extending the existing document repository pattern to support SQLite as a backend alongside other providers.

src/Foundation.Domain.Repositories.Documents · high confidence

This change introduces the core application logic for service discovery, providing a pluggable registry system and client infrastructure. It adds a \ServiceDiscoveryClient\ that supports both direct service resolution and routing via a proxy, along with a \ServiceRegistryClient\ facade for registration operations. The layer supports multiple registry backends, including a file-system based registry (\FileSystemServiceRegistry\) for local development and a router-based registry (\RouterServiceRegistry\) for distributed environments. Additionally, it includes a \ServiceDiscoveryHostedService\ for automatic service registration on startup, health check extensions for verifying client connectivity, and an echo controller for debugging service states.

src/ServiceDiscovery.Application · high confidence

This change adds a new service discovery router component that enables HTTP-based request routing and service registration management. The router exposes a proxy endpoint at \/naos/servicediscovery/router/proxy\ that forwards requests to upstream services based on \serviceName\ and \serviceTag\ headers, utilizing ProxyKit for forwarding and X-Forwarded header handling. Additionally, it provides a REST API at \/naos/servicediscovery/router/registrations\ for listing, registering, and deregistering service instances, and an echo endpoint at \/naos/servicediscovery/echo/router\ to retrieve all current registrations. The implementation supports a file-system-based service registry by default, configured via the \naos:serviceDiscovery\ section, and registers the necessary DI services and middleware to enable this functionality.

src/ServiceDiscovery.Application.Web.Router · high confidence

The Commands.Domain layer now includes a domain model for persisting commands, represented by the new Command class which wraps a MediatR request and tracks metadata such as ID, correlation ID, and creation details. To support this, an ICommandRepository interface and a corresponding CommandInMemoryRepository implementation have been added, enabling commands to be stored and retrieved from an in-memory data store.

Commands.Domain, src/Commands.Domain · high confidence

The Foundation.Domain.EventSourcing module now provides the foundational types for implementing event-sourced aggregates. This includes the IDomainEvent interface and DomainEventBase class, which standardize event metadata such as AggregateId and AggregateVersion, and introduce a ForAggregate method to attach these details to events. Additionally, the EventSourcedAggregateRoot abstract class is added, offering built-in support for tracking versioned state changes, applying incoming events, and raising new domain events that are automatically enriched with the correct aggregate identity and version before being stored in the change set.

Foundation.Domain.EventSourcing · high confidence

This change adds the foundational domain layer for the new KeyValueStorage feature. It defines the core data structures \Key\ (partition and row keys) and \Value\ (a dictionary-like row entity) within the \Naos.KeyValueStorage.Domain\ namespace, along with the \IKeyValueStorage\ interface specifying operations like \FindAllAsync\, \InsertAsync\, \UpsertAsync\, and \DeleteAsync\. Additionally, it provides \Extensions\ that offer convenient, type-safe wrappers for these operations, automatically handling table name pluralization and mapping between entity objects and storage values.

src/KeyValueStorage/Domain · high confidence

Added the foundational domain models for the job scheduling system, including the \Cron\ helper class for generating standard cron expressions, the \IJob\ interface and \Job\ implementation for defining and executing scheduled tasks with support for correlation IDs and cancellation tokens, and the \JobRegistration\ class for managing job configuration, parsing cron schedules, and determining execution timing.

src/JobScheduling/Domain/Model · high confidence

The file storage domain layer now exposes a structured API for managing files, centered around the new \IFileStorage\ and \IReadOnlyFileStorage\ interfaces. Users can perform read operations (such as retrieving file streams, metadata, and existence checks) and write operations (saving, renaming, copying, and deleting files). The model includes a \FileInformation\ class that tracks path, timestamps, size, and automatically detects content type, alongside a \PagedResults\ class that supports lazy pagination via \NextPageAsync\ for handling large file lists.

src/FileStorage/Domain/Model · high confidence

Added a new \FileStorageKeyValueStorage\ implementation that persists key-value pairs as JSON files within a directory structure (organized by table, partition, and row keys) using the \IFileStorage\ abstraction, along with the corresponding options and builder classes. Also added a stub \InMemoryKeyValueStorage\ implementation of \IKeyValueStorage\ that currently throws \NotImplementedException\ for all operations, serving as a placeholder for future in-memory support.

src/KeyValueStorage.Infrastructure.FileStorage · high confidence

This change adds two new infrastructure components to the platform. First, it introduces a \FileStorageMessageBroker\ that implements the \IMessageBroker\ interface by persisting messages as JSON files in a configurable folder and using \FileSystemWatcher\ to detect and process new messages, supporting distributed tracing and correlation IDs. Second, it adds a \LightningDbKeyValueStorage\ implementation of \IKeyValueStorage\ that uses the LightningDB library for local key-value persistence, supporting insert, upsert, update, merge, and delete operations (though table listing and deletion remain unsupported). Both components include their respective configuration options and builder classes for setup.

src/Messaging.Infrastructure.FileSystem · high confidence

The Queueing module now includes an in-memory queue implementation (InMemoryQueue) that supports configurable retry delays, retry multipliers, and dequeue intervals via InMemoryQueueOptions. This allows users to process messages in memory with customizable timing and retry logic, suitable for testing or lightweight scenarios where persistent storage is not required.

src/Queueing · high confidence

Adds a new in-memory persistence layer for the domain model, including \InMemoryRepository\ and \InMemoryRepository\<TDestination\>\ classes that support entity storage, retrieval, and upserts. The implementation features an \InMemoryEntityIdGenerator\ that automatically assigns sequential integer IDs or sequential GUIDs based on the entity's ID type, and an \InMemoryContext\ to hold the entity collection. It also provides an options builder to configure the repository with a mediator for publishing domain events, an entity mapper for DTO translation, and specific context instances, enabling developers to use this lightweight store for testing or simple scenarios without external database dependencies.

src/Foundation.Domain.Repositories/InMemory · high confidence

Added new domain event types and handlers for the job scheduling system, including \JobEvent\<TData\>\ and \JobEventHandler\<TData\>\ as the base abstractions, and a concrete \EchoJobEventHandler\ that logs job data after a short delay. This establishes the event-driven structure for processing job-related actions within the \Naos.JobScheduling.Domain\ namespace.

src/JobScheduling/Domain/Events · high confidence

The repository layer now includes an \AutoMapperEntityMapper\ implementation that delegates object and expression mapping to the global AutoMapper instance. This enables the system to map domain specifications into query expressions (e.g., converting \ISpecification\ objects into \Expression\<Func\<TDestination, bool\>\>\), allowing for more flexible and maintainable data retrieval logic compared to previous manual or alternative mapping approaches.

src/Foundation.Domain.Repositories.AutoMapper · high confidence

Adds a new \SignalRServerlessMessageBroker\ implementation within the \Naos.Messaging.Infrastructure.Azure\ namespace, enabling applications to use Azure SignalR Service as a transport for messaging. This includes the broker class itself, which handles subscribing to and publishing messages via SignalR hubs, along with supporting infrastructure such as \ServiceUtils\ for parsing connection strings and generating JWT access tokens, and a dedicated options/configuration builder (\SignalRServerlessMessageBrokerOptions\ and \SignalRServerlessMessageBrokerOptionsBuilder\) to wire up dependencies like serializers, handlers, and HTTP clients.

src/Messaging.Infrastructure.Azure.SignalR · high confidence

Adds a new \Pipeline\<TPipeIn, TPipeOut\>\ utility in the Foundation.Utilities library that enables chaining linear, one-directional processing steps. The implementation uses \BlockingCollection\ buffers to pass data between steps asynchronously via \TaskCompletionSource\, allowing users to define a sequence of transformations where the output of one step feeds into the next, with results returned as tasks.

src/Foundation.Utilities/Pipeline · high confidence

Adds the foundational domain interfaces and classes for the new queueing capability, including \IQueue\ and \IQueue\<TData\>\ for queue operations (enqueue, dequeue, process), \IQueueItem\ and \QueueItem\ for representing queued messages with lifecycle management, \QueueBase\ as an abstract base implementation, \QueueMetrics\ for tracking queue statistics, and \QueueOptionsBase\ for configuration. This establishes the domain layer for the queueing feature.

src/Queueing/Domain/Model · high confidence

Adds a new \Expando\ class in \src/Foundation.Utilities/Expando\ that extends existing objects with dynamic properties, allowing access via indexer, dynamic casting, or dictionary interface. The implementation includes a \PropertyBag\ that supports XML serialization for storing extra dynamic values, along with helper extensions like \ToExpando\ to facilitate casting objects to dynamic types.

src/Foundation.Utilities/Expando · high confidence

Adds a new set of classes and interfaces in the Foundation.Options library to standardize options configuration. This includes an OptionsBuilder base class and a generic BaseOptionsBuilder that extends Microsoft's OptionsBuilder, enabling fluent configuration. A key addition is the OptionsBase abstract class, which provides a LoggerFactory property and helper methods to create loggers, allowing options objects to easily access logging capabilities. The package also defines the IOptionsBuilder interface and extension methods to access the built target object.

src/Foundation.Options · high confidence

This change adds a new set of core libraries to the platform. It introduces the \DateTimeEpoch\ value object for handling time-based comparisons and serialization, along with \IStartupTask\ to define pre-start and post-shutdown application lifecycle hooks. A comprehensive logging and tracing schema is established via \LogKeys\, \LogPropertyKeys\, \LogTraceNames\, and \LogTrackTypes\, enabling structured correlation IDs and trace tracking across services. The update also includes \NaosException\ and \NaosClientFormatException\ for standardized error handling, \ServiceDescriptor\ for service metadata, and \EnvironmentKeys\ for configuration. Additionally, it provides \Console2\ for colored terminal output, \ExitCode\ for process status, and \IConsoleCommand\ for CLI integration. Infrastructure support is added with Azure Key Vault integration (\PrefixKeyVaultSecretManager\, \KeyVaultConfiguration\) and an \AutoMapper\ adapter with extension methods for mapping profiles.

src/Foundation.Abstractions · high confidence

The application now includes a job scheduling system, exposing a new 'jobscheduler' console command to enable, disable, list, and trigger jobs, alongside a background hosted service that automatically runs scheduled jobs. This feature is registered via the \AddJobScheduling\ extension method, which configures the scheduler, its hosted service, and command handlers within the dependency injection container.

src/JobScheduling.Application · high confidence

Adds the core application layer for the messaging system, including a new console command and handler that allow users to trigger an echo message flow via the CLI. This flow subscribes to and publishes EchoMessage and EntityMessage instances through the message broker. The change also registers a background hosted service to manage the messaging lifecycle, configures dependency injection to automatically scan and register message handlers, and sets up a subscription map with a default echo route.

src/Messaging.Application · high confidence

The Queueing domain now defines a generic \QueueEvent\<TData\>\ structure and an abstract \QueueEventHandler\<TData\>\ base class to standardize how queue items are processed. A concrete implementation, \EchoQueueEventHandler\, demonstrates this pattern by logging the text content of incoming items. The event data model includes a \CorrelationId\ property (via \IHaveCorrelationId\), enabling traceability across distributed queue operations.

src/Queueing/Domain/Events · high confidence

The \src/Commands.Application/Model\ directory now includes new base classes for the command pattern: \Command\ and \Command\<TResponse\>\ serve as the base request types, providing identifiers, correlation IDs, and creation timestamps, while \CommandResponse\<TResponse\>\ serves as the base response type, supporting result data and cancellation states. A \CommandException\ class is also added for standard service exceptions. These files establish the foundational data structures for command handling within the application layer.

src/Commands.Application/Model · high confidence

The \src/Foundation.Serialization.Csv\ area now provides a new \CsvSerializer\ implementation that wraps ServiceStack.Text for CSV operations. This serializer allows users to configure the item separator, specify a \CultureInfo\ for consistent formatting of numbers and dates, and define a custom \DateTimeFormat\. Additionally, a generic \CsvSerializer\<THeader\>\ variant is introduced, which supports mapping custom headers via a dictionary, enabling more flexible CSV structure control.

src/Foundation.Serialization.Csv · high confidence

A new interface, IEventSourcedAggregateRoot, has been added to the Foundation.Domain.EventSourcing model. This interface defines the contract for event-sourced aggregate roots, specifying properties and methods for managing versioning (Version), applying domain events (ApplyEvent), retrieving pending changes (GetChanges), and clearing those changes (ClearChanges).

src/Foundation.Domain.EventSourcing/Model · high confidence

The JobSchedulerOptions class has been added to the JobScheduling project, providing a centralized configuration and registration mechanism for scheduled jobs. This component allows users to define job behaviors using cron expressions, specify reentrancy and timeout settings, and register jobs via various overloads including action delegates, async tasks, and generic types. It integrates with the MediatR library for event-based job execution and utilizes a job factory for deferred job instance creation, effectively serving as the primary entry point for configuring the job scheduler's behavior.

src/JobScheduling · high confidence

The Operations.Domain now includes a new LogEvent entity to represent structured log data. This model captures key telemetry fields such as log level, message, timestamp, correlation ID, and service context (name, product, capability), along with a flexible Properties dictionary for custom attributes. This change enables the domain to persist and query detailed log events, supporting better observability and debugging of operations.

Operations.Domain · high confidence

The Tracing.Domain layer now includes the ISpanExporter interface, defining the contract for exporting trace spans asynchronously, alongside a new README that documents the timeline and sequence views for visualizing span hierarchies and durations.

src/Tracing.Domain · high confidence

This change introduces the foundational domain model for distributed tracing within the \Naos.Tracing.Domain\ namespace. It adds core interfaces (\ISpan\, \IScope\, \IScopeManager\, \ITracer\) and their implementations (\AsyncLocalScope\, \AsyncLocalScopeManager\, \Tracer\) to manage trace context and span lifecycle. The \AsyncLocalScopeManager\ leverages \AsyncLocal\ to maintain current scope context across asynchronous operations and integrates with MediatR to publish \SpanStartedDomainEvent\ and \SpanEndedDomainEvent\ for sampled spans. Additionally, it defines the \ITraceAdapter\ interface and initial stubs for \LoggerTraceAdapter\ and \ZipkinTraceAdapter\ to facilitate future integration with logging and distributed tracing backends.

src/Tracing.Domain/Model · high confidence

The Messaging module now includes a foundational domain model for handling messages, introducing the \Message\ class which serves as the base for all message types and includes properties for identification, correlation, origin, and status. Alongside this, new domain events \MessagePublishedDomainEvent\ and \MessageHandledDomainEvent\ have been added to track message lifecycle stages, while sample message types like \DummyMessage\, \EchoMessage\, and \EntityMessage\ are provided to demonstrate usage patterns within the system.

Messaging · high confidence

The domain layer now includes a structured eventing system built on MediatR. A new \IDomainEvent\ interface extends \INotification\ and adds \EventId\ and \CorrelationId\ properties for tracking. The \IDomainEventHandler\ interface defines a \CanHandle\ method to allow handlers to filter events, and the \DomainEventHandlerBase\ provides a concrete base class that implements logging, execution timing, and error handling for event processing.

src/Foundation.Domain/Events · high confidence

The Operations.Domain layer now includes foundational types for observability. A new ILogEventRepository interface has been added to support logging persistence. Additionally, a comprehensive metrics model is introduced, featuring a base Metric class with properties for timestamp, category, name, type, and instance, along with specialized subclasses for Counter, Gauge, and Timer metrics. The MetricTimerUnit enum defines supported time units (Nanoseconds through Days), and stub implementations for MetricsPublisher and AzureMonitoringMetricHandler are included to facilitate future metric publishing and Azure integration.

src/Operations.Domain · high confidence

The Foundation.Domain library now includes core building blocks for domain modeling, including an abstract DomainEventBase class with identity and correlation support, and specific event types for entity lifecycle changes (insert, update, delete, and their completed counterparts). It introduces an AggregateRoot base class that manages a collection of domain events to ensure aggregate consistency, alongside TenantEntity and TenantAggregateRoot classes to support multi-tenancy via a TenantId property. These types provide the structural basis for implementing event-sourced aggregates and handling tenant-scoped data within the domain layer.

Foundation.Domain · high confidence

The web layer now supports dynamic API endpoints through a new generic repository controller system. By calling \AddEndpoint\<T\>()\ in the MVC options, the application automatically registers controllers for specified entity types, with Swagger documentation automatically tagged by entity name. Additionally, the application gains the ability to register with a Consul service registry via the \UseConsulClientRegistry\ extension, enabling automatic service discovery and health checks.

src/Application.Web · high confidence

The domain layer now includes an IJobFactory interface and a ServiceProviderJobFactory implementation, enabling the creation of IJob instances via type resolution. This allows scheduled jobs to be instantiated through the service provider, supporting dependency injection for job implementations.

src/JobScheduling/Domain · high confidence

The Tracing.Domain layer now exposes domain events for span lifecycle changes (SpanStarted and SpanEnded) and introduces a LogTrace entity to persist detailed trace information. This enables consumers to react to span start/end occurrences and provides a structured model for storing trace attributes such as correlation IDs, service context, timing, and tags.

Tracing.Domain · high confidence

The \src/Foundation.Domain.Specifications\ library now provides a complete implementation of the Specification pattern, introducing \ISpecification\ and \ISpecification\<T\>\ interfaces along with base \Specification\ classes. This enables users to compose complex business rules and query filters using \And\, \Or\, and \Not\ combinators, which are implemented via \AndSpecification\, \OrSpecification\, and \NotSpecification\ classes. The library includes specific ready-to-use rules such as \HasIdSpecification\ and \HasTenantSpecification\ for common entity checks, and a \Check\ utility class that allows validating entities against specifications by throwing a new \SpecificationNotSatisfiedException\ when rules are not met. The implementation is optimized for MongoDB compatibility by using \Expression.Invoke\ to correctly combine expression trees.

src/Foundation.Domain.Specifications · high confidence

The \src/JobScheduling/Domain/Services\ area now contains the core implementation for the job scheduling system. This includes the \JobScheduler\ class which handles job registration, execution, and lifecycle management, along with interfaces \IJobScheduler\ and \IMutex\ and their implementations (\InProcessMutex\, \DistributedMutext\). Users can now register jobs with cron expressions and timeouts, trigger them manually or via schedule, and benefit from built-in logging and tracing integration within this service layer.

src/JobScheduling/Domain/Services · high confidence

Added support for storing log trace data in MongoDB. This includes a new \MongoLogTrace\ document model that maps domain trace properties (such as trace ID, span ID, service context, and timing) to MongoDB fields, a \MongoLogTraceRepository\ implementing the trace repository interface, and an AutoMapper configuration to handle serialization and deserialization between the domain model and the database document.

src/Tracing.Infrastructure.Mongo/Repositories · high confidence

The Operations service now supports persisting log events and traces to MongoDB. This change introduces a new CamelCasedMongoDBJsonFormatter to standardize JSON output, a MongoLoggingConfiguration class for settings (connection string, database/collection names, and capped collection limits), and DI extensions to register the MongoDB sink, health check, and the MongoLogEventRepository used by the dashboard. Users can enable this backend via configuration, which routes logs to a MongoDB collection and makes them queryable through the existing operations dashboard.

src/Operations.Infrastructure.Mongo · high confidence

The Operations infrastructure now supports persisting log events to MongoDB. This change introduces a new \MongoLogEvent\ data transfer object, an AutoMapper configuration to map between domain \LogEvent\ objects and MongoDB documents, and a \MongoLogEventRepository\ that implements \ILogEventRepository\ to handle storage and retrieval of these events.

src/Operations.Infrastructure.Mongo/Logging · high confidence

The Tracing.Infrastructure.Mongo module now provides a MongoDB-backed implementation for storing log traces. A new configuration class (MongoTracingConfiguration) allows users to specify the MongoDB connection string, database name, and collection name (defaulting to 'LogEvents' in 'naos\_operations'). The NaosExtensions class registers this repository via AddMongoTracing, wiring up the ILogTraceRepository interface to MongoLogTraceRepository using the configured MongoDB client and AutoMapper mappings.

src/Tracing.Infrastructure.Mongo · high confidence

The Configuration.Application module now provides a comprehensive bootstrapping framework for .NET applications. It introduces a centralized configuration factory (NaosConfigurationFactory) that automatically assembles configuration sources, including JSON files, environment variables, command-line arguments, user secrets, Azure App Configuration (with offline caching), and Azure Key Vault. The module exposes extension methods for IServiceCollection and IConfigurationBuilder to simplify service registration, offering helpers to configure and validate singleton options, conditionally add configuration providers, and register MediatR across assemblies. It also includes a NaosBuilderContext for managing service descriptors and environment details, along with health checks for Azure Key Vault connectivity.

src/Configuration.Application · high confidence

Added two new ASP.NET Core controllers to expose command-related data via HTTP. The NaosCommandRequestsController provides endpoints under the 'naos/commands' prefix to retrieve queue metrics, fetch individual command request statuses (handling Accepted, Failed, Cancelled, and other states), and get command responses. The NaosCommandsEchoController exposes an endpoint under 'naos/commands/echo' that returns a list of registered command request types.

src/Commands.Application.Web/Controllers · high confidence

The \src/Foundation.Extensions\ library has been populated with a comprehensive suite of new extension methods to simplify common development tasks. For collections, developers can now use \Add\, \AddOrUpdate\, \AddRange\, \Chunk\, \DistinctBy\, \Duplicates\, \ForEach\, \Insert\, \InsertRange\, and \Ignore\ to manipulate lists and dictionaries more fluently. String handling is enhanced with \Capitalize\, \Decapitalize\, \Contains\, \ContainsAny\, \EndsWithAny\, \EqualsAny\, \EqualsPattern\, \EmptyToNull\, and \Default\. Additional utilities include \AnyContext\ for configuring task awaiters, \As\ for safe casting, \IsBase64\, \IsNumber\, \IsDefault\, and \IsNullOrEmpty\ for type checks, and \GetFullMessage\ for detailed exception logging. Assembly metadata can now be retrieved via \GetBuildDate\ and \GetLinkerDateTime\, while GUIDs support conversion to Base64, numeric codes, and strings.

src/Foundation.Extensions · high confidence

The src/Foundation.Utilities package introduces a comprehensive set of helper classes for common development tasks. It includes EncryptionHelper and SigningHelper for data security (AES encryption and RSA signing), HashAlgorithm for computing hashes (MD5, SHA1, SHA256, etc.), and Factory for creating object instances via reflection or dependency injection. Additional utilities cover random data generation (RandomGenerator), unique ID creation (IdGenerator, SequentialGuid), retry logic (Retry, Run), rate limiting (RateLimiter), and general reflection and stream helpers.

src/Foundation.Utilities · high confidence

The \src/Foundation.Utilities.Web\ package now includes \HtmlNodeRenderOptions\, which allows users to customize the visual structure (breaks, connectors, and spacing) of rendered HTML node trees and write output directly to the HTTP response context. Additionally, a new \RouteMatcher\ class has been added to provide manual route matching capabilities for ASP.NET Core, supporting both path templates and query string constraints, while automatically casting matched route parameters to their expected types (such as int, bool, datetime, decimal, double, float, guid, and long) based on inline constraints.

src/Foundation.Utilities.Web · high confidence

Added a suite of extension methods to the \src/Foundation.Application.Web/Extensions\ directory to simplify working with ASP.NET Core HTTP objects. \HttpContextExtensions\ provides helpers for managing correlation and request IDs, retrieving URL helpers, and applying cache profiles. \HttpRequestExtensions\ adds methods to construct full URIs and detect local requests. \HttpResponseExtensions\ introduces fluent methods for writing JSON, setting headers, and returning standard HTTP status codes (OK, Created, BadRequest, etc.). Additional extensions for \IUrlHelper\ generate absolute URLs, while \WebRequestBuilderExtensions\ allows conditional configuration of the web host builder.

src/Foundation.Application.Web/Extensions · high confidence

The \src/Foundation.Serialization/Json\ area now provides a comprehensive set of utilities for JSON handling, introducing support for both \System.Text.Json\ and \Newtonsoft.Json\. A new \DefaultJsonSerializerOptions\ class configures the modern \System.Text.Json\ engine with camel-case naming, null-value ignoring, and case-insensitive property matching. Simultaneously, the library establishes robust defaults for \Newtonsoft.Json\ via \DefaultJsonSerializerSettings\ (ignoring nulls/defaults, camel-case, ISO 8601 dates) and \TypedJsonSerializerSettings\ (which enables \TypeNameHandling.All\ for polymorphic deserialization). To support these engines, the diff adds custom contract resolvers (\PrivateSetterCamelCasePropertyNamesContractResolver\, \PrivateSetterContractResolver\) that allow deserialization into properties with private setters, a \GuidConverter\ for safe GUID handling, and a \SerializationHelper\ class offering static methods for serializing/deserializing JSON and BSON from strings, streams, and byte arrays.

src/Foundation.Serialization/Json · high confidence

Added a new generic LogAnalyticsRepository that queries Azure Log Analytics via the REST API, using a LogAnalyticsEntityMap to translate between entity properties and Log Analytics columns. This enables reading log events from Azure Log Analytics as domain entities.

src/Foundation.Infrastructure.Azure.LogAnalytics/Repositories · high confidence

This change introduces a new set of base controller classes in the Application.Web layer to standardize API behavior. NaosControllerBase provides shared access to MediatR, logging, correlation, and filtering contexts. NaosReadOnlyGenericRepositoryControllerBase and NaosGenericRepositoryControllerBase implement standard CRUD operations (FindAll, FindOne, Post, Put, Delete) for entity repositories, exposing them via the 'api/\[controller\]' route. Additionally, a new NaosEchoController is added at the 'naos/echo' route to provide a simple health-check-style endpoint.

src/Application.Web/Controllers · high confidence

Added a generic \Node\<T\>\ class to represent hierarchical tree structures, providing navigation properties such as \Ancestors\, \Descendants\, \Siblings\, and \Leaves\, along with a static \ToHierarchy\ method to build trees from flat lists. Introduced an \INodeRenderOptions\ interface and two implementations (\ConsoleNodeRenderOptions\ and \StringBuilderNodeRenderOptions\) to support customizable text-based rendering of these trees. Added \NodeExtensions\ with \RenderConsole\ and \RenderAsync\ methods that allow users to visualize node hierarchies in the console or capture them as strings, using configurable separators and indentation styles.

src/Foundation.Utilities/Node · high confidence

Added three new ASP.NET Core controllers to expose operational visibility: a health check endpoint at /naos/operations/health that aggregates service status and provides an HTML dashboard; a log events endpoint at /naos/operations/logevents that retrieves log entries with filtering and an HTML dashboard view; and a log traces endpoint at /naos/operations/logtraces that retrieves distributed trace spans, renders them as a hierarchy, and provides an HTML dashboard. All endpoints support JSON responses and dedicated HTML dashboard views for browser-based inspection.

src/Operations.Application.Web/Controllers · high confidence

This change introduces the core infrastructure for RabbitMQ-based message queueing within the Naos Queueing system. It adds a new \IRabbitMQProvider\ interface and its \RabbitMQProvider\ implementation, which manages RabbitMQ connections with automatic reconnection logic using Polly retry policies. The \RabbitMQQueue\<TData\>\ class implements the queueing logic, supporting message publishing to exchanges, durable message storage, and basic get/dequeue operations. Configuration is handled via \RabbitMQQueueOptions\ and a builder pattern, allowing customization of exchange names, queue names, retry counts, and message expiration (TTL). The implementation also integrates with the existing tracing domain to propagate trace context headers in message properties.

src/Queueing.Infrastructure.RabbitMQ · high confidence

Added two new ASP.NET Core controllers to expose service context information via HTTP. The root endpoint at \naos/servicecontext\ returns a comprehensive JSON response including service descriptors, request metadata (correlation ID, IP, host), runtime details (framework, OS, build date), and links to various application actions (Swagger, health, log events). A secondary endpoint at \naos/servicecontext/echo\ provides a simpler response by echoing back the current service descriptor.

src/ServiceContext.Application/Web/Controllers · high confidence

This change introduces a comprehensive authentication infrastructure in the web application layer, adding support for four distinct authentication schemes: API Key, Basic, Azure EasyAuth, and OpenID Connect (OIDC). It provides dedicated authentication handlers (ApiKeyAuthenticationHandler, BasicAuthenticationHandler, EasyAuthAuthenticationHandler) that validate credentials via an extensible IAuthenticationService interface, including static validation services for API keys and Basic auth. The update also includes DI extension methods (AddApiKeyStaticAuthentication, AddBasicStaticAuthentication, AddEasyAuthentication, AddOidcAuthentication) to register these schemes, an OidcAuthenticationChallengeMiddleware to enforce OIDC challenges for unauthenticated requests, and a NaosAuthenticationEchoController to expose current user identity and claims for debugging.

src/Authentication.Application.Web · high confidence

This change introduces a new command handling architecture in the Commands.Application layer, featuring a BaseCommandHandler that orchestrates a chain of behaviors (such as validation, journaling, and tracing) around command execution. It also adds several Serilog log event enrichers in the Operations.Application layer to automatically attach metadata like event types, IDs, and timestamps to logs, alongside a new HttpClient delegating handler that injects service context into outgoing HTTP requests.

(repo-wide) · high confidence

The \src/Commands.Application.Web\ library now provides a complete infrastructure for exposing domain commands as HTTP endpoints. It introduces a fluent registration API (\CommandRequestOptionsExtensions\) that maps commands to specific HTTP routes (GET, POST, PUT, DELETE) and supports both synchronous responses and asynchronous queue-based processing (returning 202 Accepted with a Location header). The system automatically generates OpenAPI (Swagger) documentation for these commands via \CommandRequestDocumentProcessor\, ensuring API consumers see accurate schemas and operation details. Additionally, it includes a background queue processor (\CommandRequestQueueProcessor\) and event handler (\CommandRequestQueueEventHandler\) to manage the lifecycle of queued commands, including status tracking and optional result storage.

src/Commands.Application.Web · high confidence

The Foundation.Compression module now provides a new set of helpers for GZip compression and decompression. Users can compress and decompress byte arrays and streams via the CompressionHelper class, or work directly with files using FileCompressionHelper, which supports compressing files to .gz and decompressing them back to original paths or output streams. Extension methods are also available on Stream for convenient Compress and Decompress calls.

src/Foundation.Compression · high confidence

The application now includes a new dashboard UI framework located in the Dashboard module. This introduces a DashboardMenuItem class for defining navigation items (name, URL, icon) and an HttpResponseExtensions method to render a standardized HTML dashboard page. The default dashboard includes links to service context, health, logging, tracing, requests, messaging, queueing, job scheduling, journal, and Swagger, styled with Font Awesome icons and a custom CSS file.

src/Foundation.Application.Web/Dashboard · high confidence

The tracing domain layer now includes a complete set of model classes for representing distributed tracing spans. This introduces the \Span\ class and its \ISpanBuilder\ interface for constructing spans with trace/span IDs, operation names, tags, and logs. It also defines core enums and constants including \SpanKind\ (Internal, Server, Client, Producer, Consumer), \SpanStatus\ (Transient, Succeeded, Cancelled, Failed), and standard semantic tag/log keys (e.g., HTTP, database, peer, and error conventions) aligned with OpenTracing specifications.

src/Tracing.Domain/Model/Span · high confidence

The domain model layer now includes a set of new base classes and interfaces to support domain-driven design patterns. This introduces \Entity\<TId\>\ as the base for entities with identity and equality semantics, \ValueObject\ and \ValueObjectComparable\ for immutable value types with equality and comparison support, and \State\ for tracking lifecycle metadata (created, updated, deleted, etc.). Additionally, new interfaces such as \IEntity\, \IAggregateRoot\, \IStateEntity\, \IIdentifiable\, \ITenantEntity\, and \IHaveCorrelationId\ are provided to define contracts for domain objects, alongside a \DomainEvents\ class for managing and dispatching domain events via MediatR and a \DataDictionary\ for flexible key-value storage.

src/Foundation.Domain/Model · high confidence

The FileSystem infrastructure now includes two new implementations of the IFileStorage interface: EmbeddedFileStorage, which serves files from .NET assembly embedded resources, and FolderFileStorage, which manages files on the local disk. Both providers support configuration via dedicated options builders (EmbeddedFileStorageOptionsBuilder and FolderFileStorageOptionsBuilder) allowing users to specify assemblies or target folders and custom serializers.

src/FileStorage.Infrastructure.FileSystem · high confidence

The application now includes a new \HttpException\ base class and specific subclasses (\BadRequestException\, \NotFoundException\) that carry HTTP status codes and model state information, alongside a custom \InternalServerErrorObjectResult\ for standardized 500 responses. These types are located in \src/Foundation.Application.Web\ and provide a structured way to handle and return HTTP errors from API controllers. Additionally, an empty \ArmConfiguration\ class was added in \src/Foundation.Infrastructure.Azure.Arm\, likely serving as a placeholder for future Azure ARM configuration.

src/Foundation.Application.Web/Exceptions, src/Foundation.Application.Web/Results, src/Foundation.Infrastructure.Azure.Arm · high confidence

Added \ExpressionExtensions\ and \ExpressionHelper\ classes to the \Naos.Foundation\ namespace. \ExpressionExtensions\ provides an \Expand\ method that flattens \Invoke\ calls and expands compiled expressions, enabling complex predicate builders to work correctly with Entity Framework. \ExpressionHelper\ offers utilities for inspecting expression trees, including methods to extract property names (\GetPropertyName\), retrieve \PropertyInfo\ objects (\GetProperty\), evaluate expression values (\GetValue\), and generate delegates or string representations for specific properties.

src/Foundation.Utilities/Expressions · high confidence

This change introduces the core abstractions and implementations for the domain's data access layer. It adds a generic repository pattern (IGenericRepository, GenericRepository, and their read-only counterparts) that supports CRUD operations, specification-based queries, and result tracking via RepositoryActionResult. It also introduces FindOptions for controlling pagination, ordering, and eager loading (includes), a new EntityGuidIdGenerator for creating sequential or standard GUIDs, and an IEntityMapper interface for translating between entity types and specifications.

src/Foundation.Domain.Repositories · high confidence

This change introduces new middleware components that enhance the user experience by providing a built-in health dashboard and explicit service identity headers. The \ServiceContextMiddleware\ now serves a dashboard UI (including custom CSS and a favicon) when accessing the root path or \/index.html\, allowing users to view service details and tags directly in the browser. Additionally, the \ServicePoweredByMiddleware\ automatically adds an \X-PoweredBy: naos\ header to responses, making the underlying platform visible to clients and tools.

src/ServiceContext.Application/Web/Middleware · high confidence

The messaging layer now includes a new in-memory implementation for publishing messages and managing subscriptions. This change introduces the \IMessageBroker\ interface for core publish/subscribe operations, alongside a \SubscriptionMap\ that tracks message-handler bindings and exposes subscription details. Users can now register and unregister handlers via the broker, with the underlying map handling the lifecycle of these subscriptions in memory.

src/Messaging · high confidence

The console application now supports several new interactive commands: \process\ displays current process details (PID, memory, GC counts) and can force a garbage collection with the \-c\ flag; \echo\ prints a text message with an optional UTC timestamp; \history\ lists previously entered commands; \cls\ clears the screen; \exit\ terminates the session while saving command history to a local file; \help\ shows an overview of available commands; and \logo\ displays the application logo and service descriptor. These commands are implemented using a MediatR-based command/event handler pattern and utilize Colorful.Console for colored output.

src/Foundation.Console/Commands · high confidence

The application now includes an interactive console hosted service that allows users to execute commands via a readline interface. This service discovers registered console commands, parses user input using the CommandLine library, and dispatches them through the MediatR pipeline. It features command history persistence, basic auto-completion for specific command prefixes (echo, messaging, queueing, jobscheduler), and colored output for status feedback.

src/Foundation.Console/App · high confidence

The Operations.Application layer now includes a complete logging setup and operations service registration. A custom CamelCasedJsonFormatter ensures Serilog JSON output uses camelCase property names. Logging adapters bridge Microsoft.Extensions.Logging with the internal logging interface, and extension methods allow configuring file, console, and Seq sinks via configuration. A LoggingFilterContext provides default criteria for querying log events (environment, message, level, time range). Finally, the NaosExtensions and OperationsOptionsExtensions register the ILogEventService, HttpClient logging handlers, and interactive console support.

src/Operations.Application · high confidence

The messaging domain now includes a new handler framework located in src/Messaging/Domain/Handlers. This introduces the IMessageHandler\<T\> interface and a ServiceProviderMessageHandlerFactory for instantiating handlers via dependency injection. Concrete implementations (DummyMessageHandler, EchoMessageHandler, EchoEntityMessageHandler, and the generic EntityMessageHandler\<T\>) have been added, all of which now log incoming messages with structured correlation IDs to support distributed tracing.

src/Messaging/Domain/Handlers · high confidence

Developers can now explicitly enable service context descriptors and request tracing in the HTTP request pipeline using new extension methods. The \UseServiceContext\ and \UseNaosServicePoweredBy\ methods in \ServiceContext.Application.Web\ allow adding service metadata and powered-by headers to API responses, while \UseOperationsTracing\ in \Tracing.Application.Web\ injects a middleware to trace incoming requests. These changes simplify startup configuration by providing dedicated fluent API calls for these cross-cutting concerns.

src/ServiceContext.Application/Web, src/Tracing.Application.Web · high confidence

Added two new extension methods to the Naos.KeyValueStorage library to facilitate conversion between objects and key-value dictionaries. The \ToDictionary\ method allows any object to be serialized into an \IDictionary\<string, object\>\ by reflecting its public properties, while the \ToObject\<T\>\ method enables deserializing a dictionary back into a strongly-typed class instance by mapping dictionary keys to class properties.

src/KeyValueStorage/Extensions · high confidence

Added two new API controllers to expose queueing system information. The \NaosQueuesController\ provides a GET endpoint at \/naos/queueing/queues\ that returns metrics for all registered queues. The \NaosQueueingEchoController\ adds a GET endpoint at \/naos/queueing/echo\ which enqueues a test message and returns combined queue metrics, aiding in debugging and verification of queue connectivity.

src/Queueing.Application.Web/Controllers · high confidence

The repository layer now includes a set of new decorator classes that wrap the generic repository interface to provide additional capabilities. These include \RepositoryDomainEventsDecorator\ for publishing domain events, \RepositoryLoggingDecorator\ for structured logging, \RepositoryIncludeDecorator\ and \RepositoryOrderDecorator\ for query composition, \RepositorySpecificationDecorator\ for filtering, \RepositoryStateSoftDeleteDecorator\ for soft-delete logic, and \RepositoryTenantDecorator\ for multi-tenancy support.

src/Foundation.Domain.Repositories/Decorators · high confidence

The application now supports executing \IStartupTask\ implementations during the server lifecycle via a new \StartupTaskServerDecorator\ that wraps the underlying \IServer\, allowing tasks to run on startup and shutdown with optional delays. This is exposed through new \ServiceCollectionExtensions\ and \StartupTaskExtensions\ methods for registering these tasks. Additionally, a new generic object mapping framework has been introduced in the \Foundation.Mapping\ project, featuring an \IMapper\ interface, a concrete \Mapper\ class, and extension methods for mapping single objects and collections.

src/Foundation.Application.Web.Startup · high confidence

The application now includes built-in support for applying pending Entity Framework Core migrations and seeding initial data during startup. A new \ApplyPendingMigrationsTask\ automatically runs database migrations when the application starts, while a generic \SeederStartupTask\ allows registering entities to be inserted into the database if they do not already exist. These capabilities are exposed via a new \ServiceCollectionExtensions\ method, \AddSeederStartupTask\, which simplifies the registration of seed data with optional delays.

src/Foundation.Application.Web.Startup.EntityFramework · high confidence

The Foundation.Logging library now includes a new \LogJournal\ extension method on \ILogger\. This method allows callers to emit structured log entries with a specific key, message, type, and optional duration, automatically wrapping the log in a scope that attaches metadata such as track type (set to 'Journal'), duration in milliseconds, and a UTC timestamp. The implementation includes a fallback mechanism to handle potential \IndexOutOfRangeException\ errors during log formatting by downgrading the log level to Warning, ensuring robustness in high-throughput logging scenarios.

src/Foundation.Logging · high confidence

The application now includes dedicated health checks for system CPU and memory usage. The new SystemCpuHealthCheck and SystemMemoryHealthCheck components monitor resource utilization, reporting a Degraded status when usage exceeds 80% and an Unhealthy status when it exceeds 90%. These checks are supported by a new HealthReportResponseWriter that formats the aggregated health report into a structured JSON response for consumers.

src/Operations.Application.Web/Health · high confidence

Added new asynchronous extension methods to the repository layer that automatically enforce tenant isolation. The \FindAllAsync\ overloads now accept a \tenantId\ parameter and internally apply a \HasTenantSpecification\ to filter results, ensuring that queries only return entities belonging to the specified tenant. Similarly, \FindOneAsync\ now accepts a \tenantId\ and verifies that the retrieved entity satisfies the tenant constraint before returning it, preventing cross-tenant data leakage.

src/Foundation.Domain.Repositories/Extensions · high confidence

The tracing domain now includes a set of new sampler implementations to control which spans are recorded. Users can choose from a ConstantSampler that always samples, a NoopSampler that never samples, an OperationNamePatternSampler that samples based on operation name patterns, and a RateLimiterSampler that samples based on a rate-limiting credit system. These new classes implement the ISampler interface, allowing for more granular control over trace data volume.

src/Tracing.Domain/Model/Sampling · high confidence

The serialization layer has been restructured around a new \ISerializer\ interface and a \DefaultSerializer\ factory that defaults to MessagePack. This change introduces a suite of serializer implementations including JsonNet, Bson, Binary, Base64, Hex, and Gzip (compression), along with a Rijndael (encryption) wrapper. Extension methods are provided to simplify serialization to and from strings and byte arrays, automatically handling encoding based on whether the serializer is a text format.

src/Foundation.Serialization/Serializers · high confidence

Added a set of new extension methods to the Foundation.Utilities library to simplify common object operations. Developers can now clone objects using either BSON or JSON serialization via the new Clone extension, dump object contents to formatted or unformatted JSON strings for logging with the Dump extension, and compute SHA-256 or other algorithm hashes from byte arrays using GetHash. Additionally, the library now supports dynamic ordering of IEnumerable and IQueryable collections by property name (ascending or descending) through the OrderBy extensions, and provides a convenience Send method for MediatR that accepts dynamic request objects.

src/Foundation.Utilities/Extensions · high confidence

This release introduces new foundation libraries to enhance application capabilities. In \Foundation.Encoding\, developers now have access to \Base36\ for encoding and decoding numeric identifiers, and \Base64\ for handling URL and filename-safe Base64 encoding and decoding, which is useful for generating compact, safe strings for URLs or filenames. Additionally, \Foundation.Application.Web\ adds \ApplicationBuilderExtensions\ that provide \UseIf\ and \UseIfElse\ methods, allowing developers to conditionally add middleware to the ASP.NET Core request execution pipeline based on boolean flags or \HttpContext\ conditions, simplifying the setup of environment-specific or feature-flagged middleware configurations.

src/Foundation.Application.Web, src/Foundation.Encoding · high confidence

The \src/Foundation.Utilities.Xunit\ library now includes a comprehensive xUnit test logger that routes Microsoft.Extensions.Logging output directly to the test output window, featuring configurable formatting, structured scope tracking, and filtering logic. Additionally, the library introduces a set of custom xUnit traits (Bug, FitnessTest, IntegrationTest, SystemTest, UnitTest) with their corresponding discoverers, enabling developers to easily categorize and filter tests using standard xUnit filtering syntax.

src/Foundation.Utilities.Xunit · high confidence

The HttpClientLogHandler and its builder filter have been added to automatically log details of outbound HTTP requests and responses. This includes logging request URIs, headers, response status codes, and execution duration, with error-level logging for server errors (5xx) and warning-level for client errors (4xx). The handler integrates with the standard HttpClientFactory via an IHttpMessageHandlerBuilderFilter, ensuring that all HTTP clients configured within the application benefit from this observability without requiring manual instrumentation.

src/Foundation.Application.Web/Client/Handlers · high confidence

The application now supports RabbitMQ as a message broker. A new configuration class allows specifying connection details (host, port, credentials, virtual host) and retry counts. The DI extension registers the RabbitMQ message broker, configures subscriptions, and adds a health check for the broker connection.

src/Messaging.Application.RabbitMQ · high confidence

The application now supports RabbitMQ as a message queue provider. A new extension method allows configuring RabbitMQ connection details (host, port, credentials) and registers the necessary services, including a health check endpoint for the queueing provider.

src/Queueing.Application.RabbitMQ · high confidence

The new RepositoryTracingDecorator wraps generic repositories to automatically create distributed tracing spans for all data operations (insert, update, delete, find, upsert, count). Each span is tagged with the entity name and database type (SQL), providing visibility into repository performance and execution flow without requiring changes to existing repository implementations.

src/Tracing.Domain/Repositories/Decorators · high confidence

The Filtering.Application layer now provides a complete request filtering capability. A new middleware (RequestFilterMiddleware) intercepts HTTP requests to parse query string parameters (q, order, skip, take) into a FilterContext, which is then made available via an IFilterContextAccessor for downstream use. The package includes factories to convert this context into LINQ Specifications or FindOptions for data retrieval, and registers the necessary services via DI extensions. An echo controller is also included to expose the parsed filter context for debugging.

src/Filtering.Application · high confidence

The \src/FileStorage.Infrastructure.Ssh\ package now provides an \SshNetFileStorage\ implementation of the \IFileStorage\ interface, enabling file operations (read, write, delete, rename, copy) over SFTP using the Renci.SshNet library. This change introduces new configuration options (\SshNetFileStorageOptions\) and a builder pattern for setting connection details such as connection strings, proxy settings, and private key authentication.

src/FileStorage.Infrastructure.Ssh · high confidence

The application now registers the service context via a new \NaosExtensions\ class, which configures the \HttpClientServiceContextHandler\, establishes a singleton \ServiceDescriptor\ based on the product and capability metadata, and registers a basic health check endpoint. This change also defines a feature flag for 'ServiceContext' and sets up the echo route at 'naos/servicecontext/echo'.

src/ServiceContext.Application · high confidence

The application now includes a new exception handling middleware that intercepts unhandled errors and returns structured JSON Problem Details responses instead of raw stack traces. This middleware supports configurable detail hiding and includes specific handlers for common scenarios: BadRequestException, NaosClientFormatException, FluentValidation.ValidationException, and Kestrel's BadHttpRequestException. It automatically registers all implementations of IExceptionResponseHandler via dependency injection and suppresses the default ASP.NET Core model state invalid filter to allow these custom handlers to manage validation errors.

src/Exceptions.Application.Web · high confidence

The application now supports exporting trace spans to Zipkin through a new \UseZipkinExporter\ extension method on \OperationsTracingOptions\. This method reads configuration from the \naos:operations:tracing:zipkin\ section to determine the Zipkin host and whether the exporter is enabled. When enabled, it registers the \ZipkinSpanExporter\ as a singleton service and adds a health check endpoint at the Zipkin host's \/health\ path to monitor the exporter's connectivity.

src/Tracing.Application.Zipkin · high confidence

Introduced an architecture fitness policy in the Application layer that enforces Domain-Driven Design guidelines. This policy validates that messages, commands, queries, and their handlers reside in the Application layer, while domain entities, aggregates, events, and specifications are confined to the Domain layer. It also ensures repositories are placed in Domain or Infrastructure, prevents the Domain layer from depending on Infrastructure, and enforces specific naming conventions for messages, handlers, and interfaces.

src/Application/Fitness · high confidence

The application now includes a favicon, a logo image, and custom CSS files to enhance the visual presentation of the API documentation. Users will see a branded favicon and logo in the browser tab and UI, while the Swagger interface itself has been restyled with a dark theme (Monokai-inspired) and monospace fonts to improve readability and match the application's aesthetic.

src/Foundation.Resources/Resources · high confidence

The foundation now automatically manages entity lifecycle metadata when domain events occur. When an entity is inserted or updated, the system automatically sets the creation or update timestamp (marked with identity '\[IDENTITY\]' and source 'domainevent') and computes the entity's identifier hash, provided the entity implements the relevant interfaces. Additionally, a generic tracking handler logs all domain events to the journal for observability.

src/Foundation.Domain/Events/Handlers · high confidence

The Azure Cosmos DB infrastructure has been updated to use the Microsoft.Azure.Cosmos SDK v3, replacing the previous v2 client. This change introduces new \CosmosSqlProviderV3\ and \CosmosSqlRepository\ implementations that leverage the modern SDK's LINQ query capabilities and partition key handling. The update includes a new \CosmosConfiguration\ class for connection settings, specific extension methods for query building (such as \WhereExpression\ and \OrderByIf\), and support for the v3 document model which no longer requires the discriminator-based collection structure of v2.

src/Foundation.Infrastructure.Azure.Cosmos · high confidence

The file implementing the Cosmos DB repository for messages (MessageCosmosDbRepository) has been added but its code is entirely commented out. This means the repository class and its dependencies (IMediator, ICosmosDbSqlProvider) are not currently active or compiled into the application, effectively disabling this specific data access path for messages until the code is uncommented.

src/Messaging.Infrastructure.Azure/CosmosDb · high confidence

The IMessageRepository interface in the Messaging domain has been disabled by commenting out its code. This change effectively removes the repository contract from the active codebase, likely as part of a broader refactoring or deprecation of the messaging repository pattern.

src/Messaging/Domain/Repositories · high confidence

File storage interactions are now wrapped with two new decorators that enhance observability and organization. The FileStorageLoggingDecorator records details for every operation (such as file reads, saves, and deletions), including the size of saved files in human-readable format. The FileStorageScopedDecorator automatically prefixes all file paths with a configurable scope, supporting dynamic placeholders for environment names and date-based segments (year, month, day) to help isolate data across different contexts or time periods.

src/FileStorage/Domain/Decorators · high confidence

The application context infrastructure now supports .NET Core 3.1 alongside .NET Standard 2.0. The \INaosApplicationContext\ interface and its implementation \NaosApplicationContext\ conditionally expose \IWebHostEnvironment\ for .NET Core 3.1 or \IHostingEnvironment\ for .NET Standard 2.0. The \NaosExtensions.UseNaos\ middleware method has been updated to resolve the correct environment service based on the target framework, ensuring the application context is correctly initialized in .NET Core 3.1 environments.

src/Configuration.Application.Web · high confidence

The repository layer now includes a set of LINQ and DbContext extension methods in \src/Foundation.Infrastructure.EntityFramework/Repositories/Extensions\ to simplify data access patterns. \DbContextExtensions\ adds \SaveChangesAsync\<T\>\ to persist only a specific aggregate type while ignoring others, and \ExecuteScopedAsync\ to run operations within a transaction using the database's retry strategy. Query building is streamlined with conditional helpers: \IncludeIf\, \OrderByIf\, \SkipIf\, \TakeIf\, and \WhereExpression\ apply filtering, sorting, and pagination only when options are provided, while \TrackChangesIf\ toggles change tracking. Additionally, \ToListAsyncSafe\ ensures safe async enumeration. These utilities allow repositories to construct queries and manage transactions more declaratively.

src/Foundation.Infrastructure.EntityFramework/Repositories/Extensions · high confidence

The \src/Foundation.Infrastructure.EntityFramework/Repositories\ area now provides a new \EntityFrameworkRepository\ implementation that replaces the previous data access layer. This change introduces support for LINQKit-based specifications, allowing complex query composition via \ISpecification\ objects, and adds configurable event publishing through MediatR for insert and update operations. The repository also includes options for tracking changes and mapping between entity and destination types, providing a more flexible and testable data access pattern for users.

src/Foundation.Infrastructure.EntityFramework/Repositories · high confidence

The application now includes a set of new conventions in the \Naos.Foundation.Application\ namespace that automatically enforce security and routing policies. \AuthorizeByDefaultConvention\ ensures that all API actions require authentication by default unless explicitly marked with \\[AllowAnonymous\]\. \GeneratedControllerRouteConvention\ and \GeneratedControllerAttribute\ allow controllers to automatically derive their route prefixes from a custom attribute or controller name. Additionally, \RoutePrefixConvention\ provides a mechanism to apply a global route prefix to all controllers.

src/Foundation.Application.Web/Conventions · high confidence

The application now automatically configures outbound HTTP clients with a consistent set of middleware and resilience policies. New extension methods in \HttpClientBuilderExtensions\ and \NaosExtensions\ wire up correlation, service context, tracing, and logging handlers to every registered client by default. Additionally, clients are configured with a retry policy (exponential backoff, 3 attempts) and a circuit breaker (3 failures, 30-second break duration) to handle transient errors, while health checks are automatically registered for typed service clients.

src/Application · high confidence

Added Codecov Bash uploader script to tests directory; Added Entity Framework test infrastructure for User Accounts; Added Foundation unit test infrastructure and coverage reporting setup; Added architecture fitness tests for domain model rules; Added architecture fitness tests for sample domains; Added architecture fitness tests for the Customers sample; Added domain event handlers for UserAccount entity lifecycle events; Added domain model and events for the shopping cart sample; Added domain model classes for the Sample UserAccounts feature; Added domain model classes for the sample customer service; Added domain model, handlers, and repository interfaces for the Sample Inventory feature; Added domain specifications for user account filtering; Added initial Entity Framework migration for UserAccounts; Added integration test infrastructure and base classes; Added integration tests for Catalogs Infrastructure; Added integration tests for Cosmos DB SQL Provider V3; Added integration tests for Country domain events and repository operations; Added integration tests for Customer and Order repositories; Added integration tests for EventStore-based event sourcing; Added integration tests for Inventory and Replenishment repositories; Added integration tests for core infrastructure components; Added integration tests for customer domain event handlers; Added integration tests for the CreateCustomer command handler; Added integration tests for the Shopping Cart domain model; Added repository interfaces and implementations for the Sample Customers domain; Added sample application command and query handlers for customer operations; Added sample job implementations and data model for countries export/import; Added sample web application scaffolding for testing; Added seeder startup task and commented-out controller in UserAccounts sample; Added test composition roots and placeholder controllers for sample modules; Added test coverage for Country domain event handlers; Added test handler for countries export data with random failure simulation; Added test harness for Customer domain event handlers; Added test infrastructure for Countries sample presentation; Added test infrastructure for Country domain mapping; Added test infrastructure for Customer Order mapping; Added test infrastructure for Sample Catalogs domain; Added test module for customer application composition root; Added test project for Sample Application Web2; Added tests for Inventory Infrastructure mapping and document models; Added tests for inventory seeder startup task; Added unit tests and benchmarks for Foundation serialization serializers; Added unit tests for Azure Service Bus, Azure Storage, and In-Memory queue implementations; Added unit tests for Cosmos DB, File, LightningDB, and Table storage implementations; Added unit tests for Entity Framework repository operations; Added unit tests for EventSourcingRepository; Added unit tests for FileStorage implementations; Added unit tests for FileStorage infrastructure providers; Added unit tests for FilterContextFactory; Added unit tests for Foundation domain repositories and specifications; Added unit tests for Foundation extension methods and mapping utilities; Added unit tests for Foundation utilities; Added unit tests for Foundation utilities; Added unit tests for JobScheduling domain models and services; Added unit tests for KeyValueStorage base operations; Added unit tests for RouteMatcher utility; Added unit tests for UserAccountsClient; Added unit tests for ValidateCommandBehavior; Added unit tests for command request handling; Added unit tests for country code and name specifications; Added unit tests for customer and order domain specifications; Added unit tests for domain event messaging publisher; Added unit tests for domain model specifications and value objects; Added unit tests for file and stream compression helpers; Added unit tests for generic repository controller base classes; Added unit tests for the Country domain model; Added unit tests for the Tracing domain logic; Integration tests added for UserAccount and UserVisit repositories.

The foundation libraries and application components have been upgraded to target .NET Core 3.1 (while maintaining netstandard2.0 support for shared code) and updated to use MediatR version 8.0.1. This change brings the codebase in line with the .NET Core 3.1 LTS release and the latest MediatR features, ensuring compatibility with modern ASP.NET Core 3.1 infrastructure packages like Microsoft.AspNetCore.Mvc.NewtonsoftJson and Microsoft.EntityFrameworkCore 3.1.5.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 44.

• Code Health 39
• Architecture 69
• Maturity 64
• Readiness 47
• Security 40
• Domain Modelling 51
• Event-Driven 100
• Performance 67

• 300 commits — 284 feature/other, 16 fixes

• tests/Sample — 39 commits
• (root) — 31 commits
• src/Foundation.Domain.Repositories — 19 commits
• tests/Sample.IntegrationTests — 17 commits
• tests/Sample.Application.Web — 16 commits
• src/Foundation.Domain.EventSourcing — 12 commits
• src/Queueing.Infrastructure.Azure — 11 commits
• src/Foundation.Utilities — 10 commits
• (repo) — 9 commits
• src/Foundation.Infrastructure.EntityFramework — 9 commits
• src/Foundation.Domain — 8 commits
• src/Foundation.Extensions — 8 commits
• src/Application.Web — 6 commits
• src/Foundation.Infrastructure.Azure.Cosmos — 6 commits
• src/Foundation.Infrastructure.EventStore — 6 commits
• tests/Sample.FitnessTests — 6 commits
• src/Foundation.Application.Web.Startup.EntityFramework — 5 commits
• src/Foundation.Domain.Specifications — 5 commits
• src/Foundation.Resources — 5 commits
• src/Application — 4 commits

• fix: AggregateRoot domainevents fix
• fix: build fix
• fix: enum fix
• fix: job correlationid fix
• fix: mapper fix
• fix: messaging singleton subscriptions fix
• fix: migration fix
• fix: nuget + humanizer core regression (interpolation issue)
• fix: order fix
• fix: order fix (cosmos)
• fix: repo log decorator fix
• fix: seq fix
• fix: softdelete decorator fix (count)
• fix: style fix
• fix: succeeded fix
• fix: upsert fix
• change: +web2 + queueing
• change: AddModules
• change: AddSeederStartupTask
• change: AddSeederStartupTask
• …and 280 more

• 27 HTTP endpoints (baseline)

• 2 containers · 6 bounded contexts · 5 dependency edges (baseline)

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

vip32/Naos 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.