mizrael/EvenireDB

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.

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.

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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 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 58.

• Code Health 84
• Architecture 96
• Maturity 88
• Readiness 50
• Security 79
• Accessibility 47
• Performance 93

• 289 commits — 241 feature/other, 48 fixes

• src/EvenireDB — 83 commits
• .github/workflows — 34 commits
• (repo) — 25 commits
• src/EvenireDB.Server — 25 commits
• (root) — 21 commits
• src/EvenireDB.Client — 18 commits
• src/EvenireDB.AdminUI — 17 commits
• samples/EvenireDB.Samples.TemperatureSensors — 12 commits
• tests/EvenireDB.Server.Tests — 8 commits
• src/EvenireDB.Benchmark — 7 commits
• tests/EvenireDB.Client.Tests — 7 commits
• tests/EvenireDB.Tests — 6 commits
• tools/EvenireDB.Tools.Benchmark — 5 commits
• docs/plans — 3 commits
• src/infra — 3 commits
• scripts/benchmark.ps1 — 2 commits
• src/EvenireDB.Common — 2 commits
• src/EvenireDB.Console — 2 commits
• .github/FUNDING.yml — 1 commit
• .vscode/launch.json — 1 commit

• fix: Fix issues from Copilot PR review
• fix: Merge pull request #23 from mizrael/perf/correctness-fixes
• fix: fix: address Copilot PR review feedback
• fix: fix: critical concurrency and correctness issues
• fix: fix: make TemperatureSensors sample self-contained
• fix: fixed broken tests
• fix: fixed crazy bug with events not being actually appended
• fix: fixed flag value
• fix: fixed folder creation
• fix: fixed grpc test
• fix: fixed http transport on azure
• fix: fixed path
• fix: fixed references
• fix: fixed small issue
• fix: fixed test
• fix: fixed test
• fix: fixed test runner
• fix: fixed tests
• fix: fixed update bug
• fix: fixed workflow name
• …and 269 more

• 8 HTTP endpoints (baseline)

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

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.