Projects sharing features with Logging Operator

This project provides a framework for building Kubernetes operators and custom controllers. It offers a set of libraries designed to manage the lifecycle of cluster resources, enabling developers to synchronize the actual state of a cluster with a desired configuration through event-driven reconciliation loops. The framework distinguishes itself by providing a manager-orchestrated environment that coordinates multiple controllers and webhooks within a single process. It includes built-in support for optimistic concurrency control to prevent update conflicts and utilizes in-memory informer cac

Kubebuilder is a framework and set of scaffolding tools used to build Kubernetes APIs and controllers. It functions as an operator framework that provides generators for custom resource definitions, admission webhooks, and RBAC manifests to extend cluster functionality. The project distinguishes itself through marker-based code generation, which parses source code comments to automatically produce Kubernetes manifests and boilerplate logic. It employs a hub-and-spoke versioning model to translate data between multiple API versions and uses a three-way merge strategy to automate project migrat

Vector is a high-performance observability data pipeline designed to collect, transform, and route logs, metrics, and traces across distributed infrastructure. It functions as a modular engine that decouples data ingestion from processing and transmission, utilizing a component-based architecture to connect diverse sources to multiple destinations. The project distinguishes itself through a focus on reliability and flow control. It implements backpressure-aware data movement to prevent data loss during traffic spikes and utilizes disk-backed event buffering to ensure durability during network

Sample Controller is a reference implementation and developer toolkit for building custom controllers and operators to extend cluster capabilities with domain-specific resource types and reconciliation loops. It provides a foundational framework for defining, registering, and validating custom resource definitions and their instances to store domain-specific data within a cluster. The framework observes remote API servers for resource mutations, queueing discovered instances for asynchronous processing while listening for creation, update, and deletion events to trigger reconciliation logic.

kro is a Kubernetes resource orchestrator and API abstraction layer that enables the definition of simplified custom API surfaces. It allows users to map high-level inputs to complex templates of underlying Kubernetes objects, effectively grouping interdependent resources into single, manageable units. The project differentiates itself by automating the generation of custom resource definitions and dedicated controllers from resource graph specifications without requiring manual Go code. It employs a dependency manager that uses directed acyclic graphs to coordinate the creation, readiness, a

Agones is a Kubernetes game server orchestrator designed for hosting, scaling, and managing dedicated multiplayer game servers. It extends the Kubernetes control plane using custom resource definitions to define game server and fleet objects, utilizing a dedicated fleet manager to maintain pools of warm server instances. The system provides a game server SDK and language-specific client libraries that allow server processes to signal readiness, health, and shutdown states directly to the controller. It distinguishes itself through specialized scaling logic, including the use of WebAssembly mo

Logspout is a container log aggregator, forwarder, and routing engine designed to gather logs from Docker containers and route them to centralized external logging systems. It functions as a network-based utility that pipes container output to remote destinations such as syslog or TCP endpoints. The system features a dynamic routing engine that allows the creation and updating of log routing configurations and destination filters in real time via an HTTP interface without restarting the service. It utilizes an adapter-based architecture, enabling the development of custom output modules and t

Flagger is a Kubernetes operator designed to automate the lifecycle of application deployments through progressive delivery. It functions as a controller that monitors custom resource definitions to orchestrate complex release strategies, including canary, blue/green, and A/B testing. By continuously reconciling the desired cluster state with the actual environment, it ensures that deployments adhere to defined specifications while managing the underlying infrastructure required for traffic routing. The project distinguishes itself through a sophisticated metric-driven analysis loop that eval

lnav is a terminal-based log viewer and analyzer designed for aggregating, filtering, and analyzing multiple log files in a single chronological view. It functions as a console application that can replace the system pager, providing syntax highlighting and document navigation for system or application logs. The project distinguishes itself by mapping unstructured log data to virtual SQLite tables, enabling the use of SQL and PRQL for structured data analysis, aggregations, and relational queries. It further differentiates its capability set through native integration for retrieving and taili

This project provides a collection of implementation kits, guides, and source code designed to teach containerized application development and cluster management. It serves as a learning path for packaging applications with Docker and orchestrating workloads within Kubernetes. The repository includes practical walkthroughs for building automated delivery pipelines using containerized runners and build agents. It also provides a suite of guides for implementing cloud-native observability, deploying service meshes, and managing Kubernetes cluster configurations. The material covers a broad ran

Signale is a formatted console logging library for Node.js applications. It serves as a pluggable logging framework and stream-based log router that allows users to record system events using customizable levels, colors, and output styles. The project distinguishes itself as an interactive console logger capable of overwriting previous messages to reduce terminal clutter during long-running tasks. It also functions as an application performance monitor, providing tools to measure and track execution time between specific code points to identify performance bottlenecks. The library covers a b

Flux is a Kubernetes GitOps delivery tool used to automate application deployments by synchronizing cluster state with configurations stored in Git, OCI, or Helm repositories. It functions as a set of controllers that monitor desired state in external sources and continuously reconcile the live cluster to match those definitions. The system distinguishes itself through a multi-cluster management plane that coordinates application delivery across fleets of remote clusters from a central hub. It provides a dedicated mechanism for automated image updates, which scans container registries for new

Easyloggingpp is a header-only C++ logging framework and diagnostic tool designed for recording system events and diagnostic messages. It functions as a thread-safe logging library that synchronizes access across multiple concurrent execution threads to prevent data corruption during event recording. The framework features an asynchronous logger that processes messages on a background thread to minimize latency and prevent blocking the main application. It also acts as a log dispatcher, capable of routing data to local files, system syslog facilities, or remote network destinations for system

Uptrace is an OpenTelemetry-based observability platform designed to collect, store, and analyze distributed traces, metrics, and logs. It functions as a centralized logging backend, a distributed tracing system, and a metrics engine to monitor application performance and system health. The platform is distinguished by AI-powered operational capabilities, allowing users to query telemetry data and manage monitoring dashboards using natural language. It specifically includes specialized monitoring for generative AI pipelines, tracking token usage and response quality for LLM interactions and r

The quarkus-operator-sdk is a Java extension and framework for building custom Kubernetes operators and controllers. It provides an operator framework that generates boilerplate classes, registers reconcilers, and automatically produces custom resource definitions, role-based access control rules, deployment manifests, and Helm charts directly from application code metadata. The framework supports compile-time configuration validation to catch errors before deployment, standard dependency injection wiring for clients and controllers, and static native image compilation for generating self-con

The Prometheus Operator is a Kubernetes monitoring orchestrator and controller that manages Prometheus clusters and observability components through declarative custom resources. It functions as a custom resource controller that translates high-level Kubernetes resource definitions into the configuration files required by the underlying monitoring software. The project automates the deployment, scaling, and lifecycle of an observability stack, including the integration of components like Thanos and Alertmanager. It distinguishes itself by syncing monitoring targets, alerting rules, and scrape

Strimzi is a Kubernetes operator that automates the deployment, management, and lifecycle of Apache Kafka clusters on Kubernetes or OpenShift. It uses custom resource definitions and declarative YAML configuration to define Kafka cluster topology, broker placement, and security settings, with operator-based controllers that reconcile the desired state with the actual cluster state. The operator handles rolling updates during cluster upgrades or configuration changes to maintain availability and data integrity, and supports rack-aware broker scheduling across Kubernetes nodes and availability

Flagger is a Kubernetes progressive delivery operator that automates the gradual release of new software versions. It functions as a canary release manager and traffic shifter, integrating with service meshes and ingress controllers to control request distribution between application versions. The project focuses on reducing production risk by implementing canary releases, blue-green deployments, and A/B testing. It utilizes a metric-driven analysis loop to monitor request success rates and durations, automatically promoting a release or triggering a state-based rollback if health criteria ar

Pipeline is a Kubernetes native CI/CD framework and cloud native pipeline orchestrator. It functions as a custom resource controller that translates declarative pipeline definitions into coordinated pod executions and managed workloads. The system acts as a containerized task runner, allowing for the execution of standalone build steps and reusable tasks that process specific inputs to produce defined outputs. It enables the orchestration of complex workflows by running a sequence of independent containers as modular components within a cloud environment. The platform covers automated softwa

The etcd-operator is a custom resource controller designed to automate the deployment, scaling, backup, and recovery of distributed key-value storage clusters on container orchestration platforms. By extending container orchestration APIs with custom resource definitions, the system manages multi-node database instances through declarative configuration files and a continuous controller reconciliation loop that drives cluster provisioning, scaling, and maintenance. The operator provides automated cluster member recovery, detecting unresponsive nodes and executing membership replacements to pr

KubeVela is a cloud native application orchestrator and delivery engine for Kubernetes. It serves as an Open Application Model compliant platform designed to decouple application definitions from the underlying infrastructure and operations. The system acts as a multi-cluster delivery controller that coordinates progressive rollouts, including canary and blue-green strategies, across hybrid and multi-cloud environments. It provides a standardized model for managing complex deployment workflows and infrastructure provisioning. The platform covers broad capability areas including cloud infrast

This project is a PostgreSQL Kubernetes operator and database orchestrator designed to automate the deployment, scaling, and lifecycle management of high-availability database clusters. It functions as a controller that uses declarative manifests to provision and synchronize the state of database instances within a cluster. The system manages high availability through streaming replication and ensures constant availability during maintenance via rolling updates. It also serves as a backup and recovery manager, handling point-in-time recovery, logical backups, and cluster cloning using cloud s

RBAC Manager is a Kubernetes operator that automates the management of role-based access control and service account permissions. It functions as a controller that synchronizes cluster authorization resources with user-defined configuration files, ensuring that security settings remain consistent with established requirements. The system operates by monitoring the cluster API for changes and reconciling the current state against declarative manifests. By treating authorization as infrastructure as code, it enables teams to manage permissions through version-controlled files rather than manual

The AWS Load Balancer Controller is a Kubernetes controller that automates the provisioning and lifecycle management of cloud-native load balancing resources. It functions as an infrastructure orchestrator, translating declarative cluster configurations into specific requests for external cloud services to route traffic into containerized workloads. By implementing standard ingress and gateway specifications, the system ensures that cluster networking adheres to official industry standards for HTTP, HTTPS, and transport-layer traffic. The controller distinguishes itself through its deep integ

Fluent Bit is a cloud-native log shipper and unified telemetry collector designed as a resource-efficient data pipeline. It ingests logs, metrics, and traces from multiple sources, processing them in real-time before routing the data to external storage backends. The project functions as a real-time stream processor and OpenTelemetry log processor, capable of transforming and filtering data using SQL and conditional logic. It also acts as a distributed tracing agent that can sample traces to reduce data volume while preserving full request paths. The system provides reliable data delivery th

The OpenTelemetry .NET SDK is a set of libraries used to generate and export traces, metrics, and logs from .NET applications. It functions as an application performance monitoring tool and a distributed tracing implementation, providing the necessary infrastructure to capture system metrics and request paths across microservices. The project includes a zero-code instrumentation library that automatically captures telemetry from popular .NET frameworks without requiring manual changes to source code. It uses a provider-based API abstraction to decouple instrumentation from specific backend im

Sonar is a mobile app debugging platform and extensible toolkit that allows developers to inspect the internal state, network traffic, and system logs of mobile devices via a desktop interface. It functions as a centralized system for monitoring application behavior and troubleshooting logic and performance issues. The platform is distinguished by a plugin-based extension system that enables the development of custom debugging tools. These plugins can visualize specific application data and facilitate event exchange between a mobile device and a computer. The toolkit covers several core obse