mizrael/EvenireDB
57.3
Adequate · 8 November 2026
2.9k
lines of production code
C#
primary language
6
measurements over time
What this system is
EvenireDB is a stream-based event sourcing database engine built on .NET 10, designed to store and retrieve event data using a file-based persistence layer with optimized caching. It provides a server component that exposes event management capabilities via HTTP/REST and gRPC APIs, supporting features like stream creation, event appending with optimistic concurrency, and directional reading. The system includes a dedicated .NET client library for programmatic interaction, a Blazor-based Admin UI for visual stream management, and comprehensive tooling for benchmarking and testing.
How it got here
2023 — Initial release and core infrastructure
20 changes.
This period marks the initial release of EvenireDB, establishing the foundational stream-based event store with .NET 10, Docker support, and a comprehensive solution structure. It introduces the core domain models, gRPC and HTTP APIs, client libraries, and essential background workers for persistence and memory management. The work also includes extensive test coverage and automation scripts to support development and deployment workflows.
2024–2026 — Initial infrastructure and tooling setup
8 changes.
This period established the foundational components of EvenireDB, including the core event persistence layer, an AdminUI for stream management, and Azure infrastructure provisioning. It also introduced essential development tools, such as a benchmarking suite and an event generator CLI, to support performance measurement and testing workflows.
Features
Add TemperatureSensors sample application
The samples directory now includes a self-contained TemperatureSensors application that demonstrates using EvenireDB with ASP.NET Core. It features a background service that periodically publishes simulated temperature readings to sensor streams, and exposes REST endpoints to list available sensors and retrieve detailed historical data (including calculated averages) for individual sensors.
samples · high confidence
Added EvenireDB benchmark suite for performance measurement
Introduced a new benchmarking project in tools/EvenireDB.Tools.Benchmark to measure the performance of EvenireDB components. The suite includes benchmarks for the LRU cache, event writing, and event reading, as well as end-to-end benchmarks for the gRPC and REST APIs. It utilizes BenchmarkDotNet with .NET 10.0, providing metrics on memory and threading for these operations.
tools/EvenireDB.Tools.Benchmark · high confidence
Added EventsGenerator CLI tool for sending test events
A new command-line utility has been introduced in the EvenireDB.Tools.EventsGenerator project, allowing users to programmatically append a specified number of events to a stream on an EvenireDB server. The tool supports configuration via command-line options for the server URI, transport protocol (gRPC or HTTP), specific ports, stream ID, stream type, and event count, facilitating easier testing and integration workflows.
tools/EvenireDB.Tools.EventsGenerator · high confidence
Added baseline benchmark data for event read performance
The benchmarks directory now includes a baseline report for the \EventsProviderReadBenchmark\ under \benchmarks/baselines/\. This JSON file captures performance statistics for reading events with varying buffer sizes (4096, 65536, and 262144 bytes) on a .NET 10.0 environment, providing a reference point for future performance comparisons.
benchmarks · high confidence
Initial Admin UI pages for stream management
The AdminUI now includes core Razor Pages and components for managing event streams. Users can view a list of all streams (Streams.razor), create new streams via a type-based form (NewStream.razor), and inspect individual stream details including event counts and cached status (StreamDetails.razor). The UI also provides an error page (Error.cshtml) and standard Blazor Server layout files (\_Host.cshtml, \_Layout.cshtml) to support these features.
src/EvenireDB.AdminUI/Pages · high confidence
Initial Admin UI shell and shared components
The EvenireDB Admin UI now includes a foundational layout and a set of reusable shared components. Users can navigate via a sidebar menu and view stream data through a paginated event list that supports viewing individual payloads in a modal. The interface also provides a form to send new events to a stream, complete with validation and status feedback (loading, success, or error alerts). A stream deletion workflow is available via a confirmation modal. These changes are supported by the Open Iconic icon set and standard Bootstrap styling.
src/EvenireDB.AdminUI/Shared · high confidence
Initial event persistence layer with optimized file-based storage
The persistence module now includes the core components for storing and retrieving events: \DataRepository\ handles reading and appending event data to extent files using \ArrayPool\ buffers for efficiency; \HeadersRepository\ manages metadata (timestamps, sequences, offsets) with batched writes and configurable page sizes; \EventsProvider\ orchestrates these repositories and adds concurrency control via per-stream semaphores to ensure thread-safe appends. New interfaces (\IDataRepository\, \IHeadersRepository\, \IEventsProvider\) and the \RawHeader\ struct define the contract and binary layout for this storage mechanism.
src/EvenireDB/Persistence · high confidence
Initial gRPC event streaming service definition
Added a new Protobuf definition for the \EventsGrpcService\ that exposes two RPCs: \Read\, which returns a stream of events based on a stream ID and type, and \Append\, which accepts a batch of events with an expected version for optimistic concurrency control. The service contract includes message types for requests, responses, event data, and error handling, establishing the interface for event store operations.
src/Protos · high confidence
Initial infrastructure provisioning for Azure App Service and Container Registry
The infrastructure layer now includes Bicep templates to provision an Azure Resource Group, a Basic Container Registry, an Application Insights component, and a Linux-based Web App. The Web App is configured to pull a container image from the registry, enforces HTTPS with TLS 1.2, enables HTTP/2, and integrates with Application Insights for logging and monitoring. A container registry webhook is also configured to trigger on image pushes.
infra · high confidence
Initial release of EvenireDB Server
Introduces the EvenireDB Server application, an ASP.NET Core service exposing HTTP/1.1 and HTTP/2 APIs alongside gRPC endpoints. The server is configured with specific ports (HTTP on 80, gRPC on 5243 by default), includes health check support, API versioning, and a maximum gRPC message size of 16 MB. It utilizes an in-memory cache with a configurable capacity and max event data size, and features an EventMapper for validating and converting DTOs to internal models.
src/EvenireDB.Server · high confidence
Initial release of EvenireDB with .NET 10 target and Docker support
This change introduces the initial version of EvenireDB, a stream-based database engine for event sourcing. The project targets .NET 10.0 and includes a server component and an Admin UI, both packaged with Dockerfiles and a docker-compose configuration for easy deployment. The release also establishes the build infrastructure via Directory.Build.props and Versions.props, adds Apache 2.0 licensing, and provides a README with setup instructions, client configuration examples, and benchmarking scripts.
(repo-wide) · high confidence
Initial release of the EvenireDB AdminUI application
This change introduces the foundational structure for the EvenireDB AdminUI, a server-side Blazor application. It establishes the core application entry point (Program.cs) which configures the ASP.NET Core pipeline, including HTTPS redirection, static file serving, and Blazor Server hub mapping. The UI is wired up with routing logic (App.razor) and shared imports, while supporting configuration via appsettings files that define connection details for the Evenire server (HTTP port 5001, gRPC port 5243). Additionally, it includes utility classes for stream ID formatting and enums for alert and operation statuses to support the user interface.
src/EvenireDB.AdminUI · high confidence
Initial release of the EvenireDB client library
This change introduces the EvenireDB.Client package, providing a .NET client for interacting with the EvenireDB event store. The library supports both gRPC and HTTP transports, allowing users to append events, read streams with directional and positional filtering, and manage stream metadata (such as retrieving stream info and deleting streams). It includes a configuration record for setting server URIs, timeouts, and transport-specific ports, along with dependency injection extensions for easy integration. The client also defines specific exception types for handling errors like duplicate events or missing streams.
src/EvenireDB.Client · high confidence
Introduce core domain types for stream-based event storage
The EvenireDB.Common library now provides the foundational types required for stream-oriented event handling. This includes the StreamId and StreamType record structs to uniquely identify and categorize streams, along with StreamPosition for tracking event offsets and StreamInfo for metadata. Supporting infrastructure such as a custom JSON converter for StreamType, a Direction enum for traversal, and specific error codes (including VersionMismatch and CannotInitiateWrite) have also been added to support the upcoming stream versioning and deletion capabilities.
src/EvenireDB.Common · high confidence
Introduction of server-side DTOs for event data and error handling
New data transfer objects have been added to the server layer to structure event data and API errors. This includes an ApiError record for standardized error responses, and a set of DTOs (EventDTO, EventDataDTO, EventIdDTO) that wrap internal event models with specific types like ReadOnlyMemory\<byte\> for data and provide conversion methods to map between internal domain models and the transfer format.
src/EvenireDB.Server/DTO · high confidence
New Streams API endpoints for event management
The server now exposes a new versioned API at /api/v1/streams to manage event streams. Users can retrieve a list of streams, fetch details for a specific stream, delete a stream, append new events to a stream (with optional optimistic concurrency control via version checking), and read events from a stream with pagination and direction support. The API returns standard HTTP status codes (200, 201, 204, 400, 404, 409, 500) to indicate the result of each operation.
src/EvenireDB.Server/Routes · high confidence
New automation scripts for benchmarking, testing, and Azure deployment
Added a suite of new scripts to streamline development and deployment workflows. The \benchmark-compare.sh\ script enables running BenchmarkDotNet benchmarks against committed baselines, detecting regressions or improvements, and optionally updating the baseline. PowerShell scripts \create-infrastructure.ps1\, \dockerize.ps1\, and \publish.ps1\ automate Azure infrastructure provisioning (including manual HTTP/2 proxy flag configuration), Docker image building for server and admin UI, and publishing to Azure Container Registry. Additionally, \tests.ps1\ provides a standardized way to run unit tests with code coverage collection.
scripts · high confidence
New background workers for event persistence and memory management
Added two new background services to the server: IncomingEventsPersistenceWorker, which consumes batches of incoming events from a channel and persists them to the event store, and MemoryWatcher, which monitors process memory usage and automatically drops the oldest cached events and triggers garbage collection when memory exceeds a configured threshold.
src/EvenireDB/Workers · high confidence
New gRPC service implementation for event reading and appending
A new gRPC service implementation (EventsGrcpServiceImpl) has been added to the server, exposing Read and Append operations for event streams. The Read method supports streaming events back to clients with configurable direction and start position, while the Append method validates incoming event data and handles optimistic concurrency control errors by returning structured failure responses.
src/EvenireDB.Server/Grpc · high confidence
New utility classes for file operations and thread-safe caching
Added FileUtils to provide resilient directory and file deletion with retry logic, and introduced a new caching infrastructure consisting of the ICache interface and a thread-safe LRUCache implementation that supports atomic GetOrAdd operations and concurrent access.
src/EvenireDB/Utils · high confidence
Removals
Removed benchmarking infrastructure
The console application no longer includes the benchmarking suite for the file-based event repository. The \FileEventsRepositoryBenckmarks\ class and its runner in \Program.cs\ have been deleted, meaning users can no longer execute performance benchmarks for this component from this project.
src/EvenireDB.Console · high confidence
Behavioural changes
Event model refactored to use EventId and ReadOnlyMemory
The core Event record has been restructured to include a composite EventId (timestamp and sequence) and now stores event data as ReadOnlyMemory\<byte\> instead of byte\[\]. This change is supported by the introduction of EventId, EventIdGenerator, and EventData types, and requires updates to the EventsReader and EventsWriter to handle the new ID generation and memory layout.
src/EvenireDB · high confidence
Solution structure reorganized with dedicated test filter
The solution file has been restructured to include new projects for the server, client, gRPC, common utilities, admin UI, and benchmarking tools, while removing the console application. A new solution filter (EvenireDb.Tests.slnf) has been added to allow running tests without including the benchmark project, and the solution now uses nested project folders to organize tests, samples, tools, and CI workflows.
src · high confidence
Test coverage
Added comprehensive test coverage for EvenireDB core components; Added integration tests for EvenireDB client libraries; Added integration tests for server routes; Initial server-side integration tests for gRPC and persistence.
Dependencies
EvenireDB project structure and dependency overhaul
This change restructures the EvenireDB solution by introducing new projects for the client library, server, admin UI, and benchmarks, while renaming the console project to EvenireDB.Grpc. It upgrades the target framework to .NET 10 (via $(TargetFrameworkVersion)) and updates core dependencies, including Grpc.AspNetCore to 2.71.0, Google.Protobuf to 3.33.1, and Microsoft.Extensions packages to 10.0.0. The test suite has been modernized by removing FluentAssertions in favor of NSubstitute and updating xunit, Microsoft.NET.Test.Sdk, and coverlet to their latest versions.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.
Score
- CAI 57 → 57 (-0.2)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 78 → 78 (+0.0)
- Architecture 81 → 81 (+0.0)
- Maturity 68 → 68 (+0.3)
- Readiness 51 → 51 (+0.0)
- Security 77 → 73 (-3.4)
- Accessibility 51 → 51 (+0.1)
- Performance 95 → 93 (-1.6)
Resolved (9)
- Inconsistent naming and parameterization for reading events. The interface method ReadAsync requires a StreamPosition, while the extension method ReadAsync omits the position parameter (implying a default or 'latest' behavior), and ReadAllAsync suggests reading from the beginning or all streams but takes a single StreamId. This creates confusion about whether ReadAsync on the extension is a convenience wrapper for a specific position or a different operation entirely.
- Typo in method name: 'Steam' instead of 'Stream'. The method DeleteSteamAsync appears to be a typo for DeleteStreamAsync, as evidenced by the test name DeleteSteamAsync_should_delete_existing_stream which mirrors the typo, and other related methods like GetStreamInfoAsync and MapEventsRoutes which correctly use 'Stream'.
- XML-doc coverage: EvenireDB (src/EvenireDB/EvenireDB.csproj)
- XML-doc coverage: EvenireDB.AdminUI (src/EvenireDB.AdminUI/EvenireDB.AdminUI.csproj)
- XML-doc coverage: EvenireDB.Client (src/EvenireDB.Client/EvenireDB.Client.csproj)
- XML-doc coverage: EvenireDB.Common (src/EvenireDB.Common/EvenireDB.Common.csproj)
- XML-doc coverage: EvenireDB.Samples.TemperatureSensors (samples/EvenireDB.Samples.TemperatureSensors/EvenireDB.Samples.TemperatureSensors.csproj)
- XML-doc coverage: EvenireDB.Server (src/EvenireDB.Server/EvenireDB.Server.csproj)
- XML-doc coverage: EvenireDB.Tools.Benchmark (tools/EvenireDB.Tools.Benchmark/EvenireDB.Tools.Benchmark.csproj)
New (1)
- Medium: security finding (details withheld)
API surface
- Unchanged — 8 HTTP endpoints
Architecture
- Unchanged — 2 containers · 4 contexts · 3 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
mizrael/EvenireDB was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 8 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 9196d98b1e7c53f548029f3c50852e8f4d769e33 — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-45ab2cab63de.