guoming/Hummingbird

Hummingbird is a .NET development framework that provides a comprehensive set of extensions for building distributed, cloud-native applications. It offers standardized abstractions and implementations for critical infrastructure concerns, including service discovery, event-driven messaging, and distributed coordination. The framework simplifies integration with popular technologies such as Redis, Kafka, RabbitMQ, Consul, and Nacos, while also providing utilities for caching, background job scheduling, and observability.

21 changes.

This period marks the initial release and rapid expansion of the Hummingbird framework, establishing a comprehensive suite of distributed infrastructure components. The work focused on implementing core capabilities such as service discovery, distributed locking, event bus integration with Kafka and RabbitMQ, and observability tools like OpenTracing and metrics collection. The codebase grew to include specialized extensions for caching, ID generation, and database logging, laying the foundation for a modular, microservices-ready architecture.

9 changes.

This period focused on expanding the framework's ecosystem by adding support for external distributed systems, including Nacos, Apollo, and Jaeger for configuration and tracing. It also introduced providers for background job scheduling, file storage, and caching, while adding comprehensive unit tests to verify the new components.

Users can now register Consul-based service discovery and dynamic routing in their applications by calling the new \AddConsulDynamicRoute\ extension methods. This adds the necessary services to the DI container, including a configured \IConsulClient\ and a \ConsulServiceLocator\, enabling automatic service registration and discovery for both ASP.NET Core and ASP.NET Framework environments.

src/Hummingbird.Extensions.DynamicRoute.Consul/Extersions · high confidence

A new implementation for generating distributed work IDs using Consul as the coordination backend. This includes a configuration class (ConsulConfig) for registry address, port, token, and region settings, along with a ConsulWorkIdCreateStrategy that uses Consul sessions and key-value locks to allocate unique worker IDs across instances. A dependency injection extension is also provided to register the Consul client and strategy in the service container.

src/Hummingbird.Extensions.UidGenerator.ConsulWorkIdStrategy · medium confidence

The Hummingbird DynamicRoute module now includes a Consul implementation for service discovery. This adds the ability to register services with Consul, including support for multiple ports and health checks. The service locator can now query services across multiple datacenters, aggregating results from all available Consul clusters. Configuration for the Consul registry (address, port, token, region, and health check settings) is handled via the new ConsulConfig class.

src/Hummingbird.Extensions.DynamicRoute.Consul · high confidence

Added new files to integrate Jaeger distributed tracing into the Hummingbird framework. The \TracingConfiguration\ class defines settings for the tracer, including service name, endpoint, sampler type, and flush interval. The \DependencyInjectionExtersion\ class registers the Jaeger tracer with the service collection, configuring the sender, sampler, and reporter based on the provided configuration. This allows users to easily enable OpenTracing support with Jaeger in their applications.

src/Hummingbird.Extensions.OpenTracing.Jaeger · high confidence

Users can now verify the health of a Kafka broker by adding a dedicated health check. The new \AddKafkaCheck\ extension methods on \HealthCheckBuilder\ allow you to configure a check that produces a test message to a specified Kafka topic and confirms persistence, returning a healthy or unhealthy status based on the result.

src/Hummingbird.Extensions.HealthChecks.Kafka · high confidence

Users can now persist event bus logs to MySQL or SQL Server databases. This change introduces new \MySqlLogging\ and \SqlServerLogging\ extensions that register database connection factories, configuration options (connection string, timeout, table prefix), and \IEventLogger\ implementations. The providers support saving event logs, marking events as published or failed, and querying for un-published messages, with database schemas and SQL scripts included for both backends.

src/Hummingbird.Extensions.EventBus.MySqlLogging, src/Hummingbird.Extensions.EventBus.SqlServerLogging · high confidence

The Hummingbird.Extensions.Configuration.Nacos package now provides extension methods to integrate Nacos as a configuration source. Developers can register Nacos configuration providers via the standard IConfigurationBuilder.AddNacosConfiguration() overloads, which map local configuration options to the underlying Nacos V2 SDK settings.

src/Hummingbird.Extensions.Configuration.Nacos · high confidence

The Hummingbird framework now supports dynamic routing via Nacos. This change introduces a new Nacos extension that registers a service locator to discover and filter healthy service instances from Nacos, with optional in-memory caching of service endpoints.

src/Hummingbird.Extensions.DynamicRoute.Nacos · medium confidence

Users can now store and serve files using Alibaba Cloud OSS or local physical storage. The change introduces configuration classes and dependency injection extensions for both providers, including an \OssFileProvider\ with local caching and metadata caching, and a \PhysicalFileSystemBucket\ for local disk operations.

src/Hummingbird.Extensions.FileSystem, src/Hummingbird.Extensions.FileSystem.Oss, src/Hummingbird.Extensions.FileSystem.Physical · high confidence

The Hummingbird.Extensions.OpenTracing package now provides OpenTracing support. This includes a new Tracer class that wraps the OpenTracing API to manage spans, log requests and responses, and handle exceptions. A builder interface (IHummingbirdOpenTracingBuilder) and its implementation (HummingbirdOpenTracingBuilder) are added to configure tracing options. An extension method (AddOpenTracing) is provided on IHummingbirdHostBuilder to register the tracing services with the dependency injection container.

src/Hummingbird.Extensions.OpenTracing · high confidence

The Hummingbird framework now supports scheduling background jobs using the Quartz library. Users can configure cron-based triggers via the new \CornJobConfiguration\ settings, which are wired into the dependency injection container and registered as a hosted service (\CornJobSchedulerHostedService\) that initializes the Quartz scheduler at application startup.

src/Hummingbird.Extensions.Quartz · high confidence

The Hummingbird framework now includes built-in support for monitoring RabbitMQ status and generating unique IDs. Developers can use the new \AddRabbitMQCheck\ extension to configure health checks for RabbitMQ connections, specifying endpoints, authentication, and virtual hosts. Additionally, the \Hummingbird.Extensions.UidGenerator\ module introduces a Snowflake-based ID generator, allowing services to register and resolve unique ID generators via dependency injection, with configurable work ID creation strategies (static or hostname-based).

src/Hummingbird.Extensions.UidGenerator · high confidence

Introduces a new caching extension (\Hummingbird.Extensions.Cache\) that provides a generic \IHummingbirdCache\<T\>\ interface and dependency injection registration for both in-memory and Redis-backed caches. Additionally, a new request limiting extension (\Hummingbird.Extensions.RequestLimit\) is added, providing middleware for configuring request rate limits and timeouts via \RequestRateLimitConfiguration\ and \RequestTimeoutConfiguration\.

src/Hummingbird.Extensions.Cacheing · high confidence

The Hummingbird framework now supports distributed locking via Redis. This change introduces a new \IDistributedLock\ interface and a \RedisDistributedLock\ implementation that manages lock acquisition, renewal, and release using a Redis cache manager. Users can configure the Redis connection (servers, password, SSL, database number, key prefix) and register the lock service via \AddRedisDistributedLock\ in the dependency injection container.

src/Hummingbird.Extensions.DistributedLock.Consul, src/Hummingbird.Extensions.DistributedLock.Redis · high confidence

This change introduces a new health check subsystem across the codebase. For ASP.NET Core, it adds a \HealthCheckMiddleware\ and \HealthCheckStartupFilter\ to expose health status via HTTP, along with \IWebHostBuilder\ extension methods (\UseHealthChecks\) to configure the check via URL path or port. For ASP.NET (classic), it provides a \HealthCheckHandler\ for similar HTTP exposure. The core \CachedHealthCheck\ implementation adds caching to health checks to avoid repeated calls. Additionally, it adds specific health check implementations for MongoDB, MySQL, Redis, and SQL Server, each providing an \AddCheck\ extension to register a corresponding health probe.

(repo-wide) · high confidence

The Hummingbird framework now provides a configurable, resilient HTTP client that automatically applies retry and circuit-breaker policies (via Polly) to HTTP requests. This new feature allows developers to register a resilient client through the DI container, which supports GET, POST, PUT, and DELETE operations, as well as file uploads. The client includes URL resolution for service discovery, automatic header propagation, and logging. A standard, non-resilient client is also provided for simpler use cases.

src/Hummingbird.Extensions.Resilience.Http · high confidence

Users can now integrate the Apollo configuration center into their applications by using the new AddApolloConfiguration extension method. This method allows for the registration of multiple configuration namespaces with their respective file formats, enabling centralized configuration management through the Humingbird.Extensions.Configuration.Apollo library.

src/Hummingbird.Extensions.Configuration.Apollo · high confidence

Introduced a new \Hummingbird.Extensions.Canal\ module that enables the application to subscribe to and process data change events from a Canal server. The update adds configuration models (\CanalConfig\), a background hosted service (\CanalClientHostedService\) to manage the connection lifecycle, and interfaces for connectors and formatters. It includes a default \ConsoleConnector\ for debugging and formatters for \CanalJson\ and \MaxwellJson\ output formats, allowing users to easily integrate Canal-based CDC (Change Data Capture) into their Hummingbird applications.

src/Hummingbird.Extensions.Canal · high confidence

A new hosted service, ConsulServiceRegisterHostedService, has been introduced to manage the lifecycle of a Consul service registration. The service registers the instance upon application start, performs periodic heartbeats using a timer, and handles deregistration when the application stops.

src/Hummingbird.Extensions.DynamicRoute.Consul/HostedService · high confidence

A new extension class was added to the AspNetCore.Metrics module, providing dependency injection setup and web host builder extensions. This enables the application to collect metrics and report them to InfluxDB (with configurable address, database, credentials, and retry policies) as well as expose Prometheus-compatible endpoints.

src/Hummingbird.AspNetCore.Metrics · high confidence

New extension methods are added to the Hummingbird RabbitMQ event bus to support distributed tracing and message reliability. A new DateTimeExtersions class provides timestamp conversion utilities. The EventExtersions class introduces methods to attach trace IDs, configure retry strategies with configurable delays, and handle dead-letter queues for failed or timed-out messages. Additionally, the DependencyInjectionExtersion class provides a fluent API for configuring RabbitMQ connection pools, authentication, and exchange settings.

src/Hummingbird.Extensions.EventBus.RabbitMQ/Extersions · medium confidence

The Hummingbird.Example application now includes controllers and configuration for distributed locks (Redis), caching (Redis), and event bus (Kafka/RabbitMQ). It also supports configuration via Apollo and Nacos, and integrates with OSS for file storage. The example app demonstrates usage of these features through new controllers (DistributedLockController, CacheingController, MQController, etc.) and corresponding configuration files (appsettings-local.json, bootstrap.json).

example · high confidence

The Hummingbird framework is introduced as a development scaffold providing distributed locks (Redis, Consul), caching, ID generation, health checks, message buses (RabbitMQ, Kafka), and more. This initial commit establishes the project structure, solution file, and documentation.

(repo-wide) · high confidence

The Hummingbird.Extensions.EventBus package now provides a foundational event bus architecture, including the IEventBus, IEventHandler, IEventBatchHandler, and IEventLogger interfaces, alongside the EventLogEntry and EventResponse models. This adds support for publishing and subscribing to events, with dependency injection extensions to automatically register all IEventHandler and IEventBatchHandler implementations and wire up subscriber handlers during application startup.

src/Hummingbird.Extensions.EventBus · high confidence

Added new \DefaultKafkaPersisterConnection\ and \EventBusKafka\ classes to provide a Kafka-backed implementation of the event bus. The \EventBusKafka\ class manages producer and consumer connections with configurable retry and timeout policies, while \DefaultKafkaPersisterConnection\ handles the underlying Kafka client lifecycle and resource disposal.

src/Hummingbird.Extensions.EventBus.Kafka/Implements · high confidence

The Kafka event bus extension now provides a complete integration layer. Dependency injection is configured via \AddKafka\, allowing users to set up producer and consumer configurations with options for retry attempts, timeouts, and load balancing. New extension methods enable batch consumption (\ConsumeBatch\) and batch production (\ProduceBatch\) for improved throughput, while \EventLogEntry\ extensions add support for timestamps, trace IDs, retry strategies, and delayed/dedicated dead-letter queue routing.

src/Hummingbird.Extensions.EventBus.Kafka/Extersions · high confidence

Added new interface definitions for Kafka event bus infrastructure: IKafkaPersistentConnection (providing GetProducer and GetConsumer methods), IKafkaPersisterConnectionLoadBalancer (leasing connections), and IKafkaPersisterConnectionLoadBalancerFactory (creating load balancers). These abstractions support the Kafka extension's connection management and load balancing capabilities.

src/Hummingbird.Extensions.EventBus.Kafka/Abstractions · high confidence

The RabbitMQ-based implementation of the event bus has been added, introducing the \EventBusRabbitMQ\ class and its supporting \DefaultRabbitMQPersistentConnection\ class. This change enables the application to publish and subscribe to events via RabbitMQ, featuring connection pooling, automatic retry policies for network failures, and configurable timeout and parallelism settings for both producers and consumers.

src/Hummingbird.Extensions.EventBus.RabbitMQ/Implements · medium confidence

Added new unit tests for the caching module (CacheManager), distributed lock implementations for Consul and Redis, the Consul service locator, and the MacAddressProcessIdWorkId UID generation strategy. These tests verify core functionality such as concurrent cache operations, lock acquisition and release, service discovery lookups, and unique ID generation logic.

test · high confidence

The Hummingbird library's .csproj files have been updated to include new dependencies and target frameworks. Key additions include Quartz for job scheduling, App.Metrics for metrics collection, and various client libraries for Kafka, Redis, Consul, Nacos, Apollo, and OSS. The project files also specify target frameworks such as netstandard2.0, netcoreapp3.1, and net5.0, ensuring compatibility across different .NET versions.

(dependencies) · high confidence

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

• CAI 41 → 40 (-0.3)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 50 → 49 (-0.7)
• Architecture 85 → 85 (-0.0)
• Maturity 55 → 51 (-3.4)
• Readiness 23 → 24 (+0.8)
• Security 71 → 70 (-0.3)
• Performance 63 → 63 (+0.0)

• Bounded contexts not declared
• Duplicated block (11 lines × 2) (src/Hummingbird.Extensions.DynamicRoute.Consul/ConsulServiceLocator.cs)
• Duplicated block (6 lines × 2) (src/Hummingbird.Extensions.EventBus.RabbitMQ/Implements/EventBusRabbitMQ.cs)
• Duplicated block (6 lines × 2) (src/Hummingbird.Extensions.EventBus.RabbitMQ/Implements/EventBusRabbitMQ.cs)
• Duplicated block (8 lines × 2) (src/Hummingbird.Extensions.DynamicRoute.Consul/ConsulServiceDiscoveryProvider.cs)
• Duplicated block (9 lines × 2) (src/Hummingbird.Extensions.HealthChecks/Checks/NumericChecks.cs)
• Further orphaned files (smaller)
• High CVE: Microsoft.NETCore.App 2.1.0
• High CVE: Microsoft.NETCore.App 2.1.0
• High CVE: Microsoft.NETCore.App 2.1.0
• High CVE: Microsoft.NETCore.App 2.1.0
• High CVE: Microsoft.NETCore.App 2.2.0
• High CVE: Microsoft.NETCore.App 2.2.0
• High CVE: System.Net.Http.WinHttpHandler 4.0.0
• High CVE: System.Net.Http.WinHttpHandler 4.0.0
• High CVE: System.Net.Security 4.0.0
• High CVE: System.Net.Security 4.0.0
• High CVE: System.Net.Security 4.3.0
• High CVE: System.Net.Security 4.3.0
• High CVE: System.Text.Encodings.Web 4.0.0
• …and 30 more

• Documentation: no architecture or design documentation (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Dormant codebase
• Duplicated block (10 lines × 2) (src/Hummingbird.Extensions.Resilience.Http/Extersions/DependencyInjectionExtersion.cs)
• Duplicated block (10 lines × 2) (src/Hummingbird.Extensions.Resilience.Http/Implements/ResilientHttpClient.cs)
• Duplicated block (10 lines × 2) (src/Hummingbird.Extensions.UidGenerator.ConsulWorkIdStrategy/DependencyInjectionExtersion.cs)
• Duplicated block (11–13 lines × 2) (src/Hummingbird.Extensions.DynamicRoute.Consul/ConsulServiceLocator.cs)
• Duplicated block (12 lines × 2) (src/Hummingbird.Extensions.EventBus/Extersions/DependencyInjectionExtersion.cs)
• Duplicated block (14 lines × 2) (src/Hummingbird.Extensions.Cacheing/StackExchange/RedisCacheManage.cs)
• Duplicated block (14 lines × 2) (src/Hummingbird.Extensions.DistributedLock.Consul/Extersions/DependencyInjectionExtersion.cs)
• Duplicated block (14 lines × 2) (src/Hummingbird.Extensions.Resilience.Http/Extersions/DependencyInjectionExtersion.cs)
• Duplicated block (17 lines × 2) (src/Hummingbird.Extensions.HealthChecks.MySql/HealthCheckBuilderMySqExtensions.cs)
• Duplicated block (17–18 lines × 2) (src/Hummingbird.Extensions.EventBus.Kafka/Implements/EventBusKafka.cs)
• Duplicated block (17–21 lines × 2) (src/Hummingbird.Extensions.EventBus.Kafka/Implements/EventBusKafka.cs)
• Duplicated block (183 lines × 2) (src/Hummingbird.Extensions.EventBus.Kafka/Extersions/EventExtersions.cs)
• Duplicated block (19–21 lines × 2) (src/Hummingbird.Extensions.EventBus.Kafka/Implements/EventBusKafka.cs)
• Duplicated block (20–21 lines × 4) (src/Hummingbird.Extensions.EventBus.MySqlLogging/Implements/MySqlEventLogger.cs)
• Duplicated block (21 lines × 2) (src/Hummingbird.Extensions.Configuration.Nacos/Extersions/DependencyInjectionExtersion.cs)
• Duplicated block (21 lines × 2) (src/Hummingbird.Extensions.EventBus.Kafka/Extersions/DateTimeExtersions.cs)
• …and 85 more

• Unchanged — 7 HTTP endpoints

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

guoming/Hummingbird 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.