Open-source alternatives to Log

This PHP caching library provides a key-value storage abstraction designed to reduce application computation time by storing and retrieving frequently accessed data. It implements the PSR-6 standard for caching interfaces to ensure interoperability between different libraries. The project includes a legacy cache adapter that wraps modern standardized cache pools. This allows systems in transition to maintain compatibility by converting between legacy caching implementations and unified interfaces. The library covers a range of storage capabilities, including a filesystem cache store for pers

This project provides a formal specification and a set of standard Java interfaces for asynchronous stream processing. It defines a standardized protocol for passing sequences of elements between publishers and subscribers across different threads, centering on a reactive streams specification for the JVM. The project focuses on interoperability by providing a common API that allows different asynchronous streaming libraries to work together. This is achieved through a standard set of interfaces and bridging mechanisms that translate between incompatible streaming specifications. The specifi

spdlog is a high-performance C++ logging library designed to record diagnostic messages and application events. It serves as an asynchronous logging framework and thread-safe library that coordinates access across concurrent threads to maintain message integrity. The project functions as a multi-target log router, distributing single events to multiple destinations such as consoles, files, and system daemons. It includes a log rotation manager that handles file lifecycles through basic, rotating, or daily rollover strategies to prevent disk exhaustion. The library covers a broad range of cap

Loguru is a Python logging library and thread-safe framework designed for recording system events and diagnostic messages. It functions as a structured logging tool that can serialize messages into JSON strings with metadata for automated parsing and analysis. The library includes a specialized exception tracker that captures unhandled crashes across main and background threads, rendering detailed stack traces that include local variable values. It further distinguishes itself through a unified routing pipeline that can intercept messages from the standard library logging module and dispatch

This project is a PHP interface library that provides a component interoperability layer. It consists of a set of framework-agnostic contracts and standardized definitions that enable different libraries to work together via a consistent contract. The library focuses on providing minimal shared interfaces and API definitions, allowing software components to be used across different PHP projects regardless of the underlying framework. This approach decouples application logic from concrete framework implementations. The project specifically covers service container abstraction and dependency

swift-log is a standardized logging API and abstract logging layer for Swift applications and libraries. It provides a unified interface for emitting log messages, decoupling the act of recording events from the specific storage or display implementation. The system functions as a logging backend interface, allowing log output to be routed to custom third-party destinations through the implementation of pluggable handlers. This framework focuses on Swift application observability and logging standardization, ensuring a consistent set of requirements for recording system behavior across diffe

CocoaLumberjack is a logging framework designed for Apple platforms, providing a system for capturing, filtering, and managing diagnostic messages within mobile and desktop applications. It serves as a tool for monitoring software health and troubleshooting runtime issues by recording application events across various severity levels. The framework utilizes a modular architecture that allows developers to define custom log levels and route diagnostic output to multiple concurrent destinations, including the system console, local files, and remote servers. It incorporates an asynchronous pipel

This project is an OpenTelemetry reference implementation and distributed microservices environment used to demonstrate the collection and export of traces, metrics, and logs. It serves as a telemetry pipeline showcase and a polyglot instrumentation example, providing a sandbox for practicing distributed tracing and monitoring within a Kubernetes cluster. The system features a polyglot architecture to demonstrate consistent, vendor-neutral telemetry implementation across multiple programming languages. It includes a simulated environment for testing telemetry interoperability and troubleshoot

ReflectionCommon is a PHP reflection interface library and code analysis abstraction. It serves as a foundation for static analysis by providing a shared specification for representing classes, methods, and properties during programmatic code inspection. The project standardizes the reflection API to decouple analysis tools from specific PHP reflection implementations. This ensures that different analysis implementations can work interchangeably through a consistent layer of interfaces. The library covers the domain of PHP code analysis and static analysis tooling, establishing a common way

Consola is a diagnostic logging utility and log output manager that provides a unified interface for Node.js and web browser environments. It functions as a scoped logging framework and a tool for capturing user text, confirmations, and selections through interactive console prompts. The project distinguishes itself through a system for creating specialized logger instances with inherited defaults and unique tags for contextual tracking. It also features a pluggable reporter interface that allows for the redirection of standard output to custom logging destinations and external reporters. Th

Winston is a versatile logging library for Node.js designed to record system events and metadata. It functions as a multi-transport log manager that routes data to various destinations and a structured log formatter that transforms entries into JSON or plain text. The project is distinguished by its pluggable transport architecture, which decouples the logging interface from delivery mechanisms. This allows for the creation of custom transport extensions and the use of hierarchical logger instances to inherit configurations while attaching persistent metadata to downstream messages. The libr

JSON Canvas is an interoperable whiteboard specification and data exchange format. It provides a standardized JSON schema for representing nodes, edges, and spatial layout information, allowing different infinite canvas and digital whiteboard applications to read and write the same files. The project focuses on digital whiteboard interoperability and spatial data standardization to prevent vendor lock-in. By using a coordinate-based layout mapping and a machine-readable format, it enables cross-platform visual mapping and the migration of spatial data between different software environments w

This project establishes a collection of interoperability standards for the PHP ecosystem. It defines common technical specifications to ensure that separate software projects and libraries can work together without compatibility issues. The standards cover a variety of core domains, including specifications for class autoloading through namespace-to-path mapping, shared coding style guides for codebase uniformity, and common component interfaces for services such as logging and caching. It also defines shared specifications for network communication to ensure consistent interactions between

This project is a comprehensive sample library and implementation guide for ASP.NET Core. It provides a collection of practical examples and projects that demonstrate how to build web applications, RESTful APIs, and high-performance services. The repository focuses on a variety of architectural patterns, including the development of Minimal APIs, contract-first gRPC services, and real-time communication using WebSockets and Server-Sent Events. It includes detailed implementations for user identity and security, such as token-based authentication and CSRF protection. The codebase covers a bro

Boto3 is the AWS SDK for Python, providing a programmatic interface for managing and automating AWS cloud infrastructure and services. It serves as a cloud management API client and resource manager for provisioning, configuring, and scaling virtual servers, databases, and storage. The library enables the implementation of infrastructure-as-code through declarative templates and scripts, allowing for the deployment of identical resource stacks across multiple accounts and geographic regions. It also provides a framework for coordinating distributed workflows, serverless functions, and contain

Simple Cache is a technical specification and interface standard for PHP applications. It defines a common set of methods for interacting with cache storage, ensuring that different storage implementations can be used interchangeably. As the PSR-16 implementation standard, it provides a consistent way for independent PHP libraries and frameworks to store and retrieve cached data. This interoperability allows software packages to work with any compliant cache backend without requiring changes to the application code. The specification focuses on standardizing cache interfaces and interactions

Acra is an Android crash reporting framework and diagnostic data collector designed to detect failures and capture device diagnostics, system logs, and application state. It serves as an embeddable library for capturing and processing crash reports, providing a pipeline to send this data to custom backends or via email. The project features a plugin-based sender architecture that allows reports to be routed through HTTP endpoints, email clients, or proprietary backend implementations. It includes a user-controlled reporting system with preference toggles and interactive dialogs to manage user

This project is a specialized browser debugging interface designed to monitor DOM elements, network traffic, and JavaScript execution. It provides a client-side user interface for inspecting and debugging web applications, allowing for the real-time modification of CSS styles and the investigation of the JavaScript runtime. The toolkit includes dedicated analysis tools for WebAssembly, featuring disassembly highlighting, scope inspection, and binary execution profiling. It also provides a network traffic inspector for analyzing HTTP requests and a CSS style editor for testing properties and a

Pulse is an Apple platform network logger used for recording and inspecting network traffic and system logs directly within applications. It functions as an on-device network inspector and traffic export tool, allowing for the capture of outgoing requests and the transmission of logs to external systems. The project includes a remote log streamer for the real-time transmission of device logs to an external viewer for live monitoring. It further provides an integrated interface for viewing recorded network requests and system logs on the device without the requirement of an external proxy. Th

POCO is a comprehensive C++ application framework that provides a cross-platform set of libraries for building network-centric applications. It offers a unified abstraction layer that wraps platform-specific APIs, enabling the same code to run across desktop, server, mobile, IoT, and embedded systems. The framework is organized into modular libraries that can be compiled and linked selectively, allowing developers to include only the components their application needs. The framework distinguishes itself through its broad coverage of application infrastructure needs, including threading and sy

NLog is an open-source logging framework for .NET that functions as a structured logging library and log routing engine. It captures log events with named parameters as searchable data rather than plain text and directs these messages to various output destinations based on severity and source. The framework is designed as an extensible platform, supporting custom targets, layout renderers, and filters that can be loaded from external assemblies or defined in code. It features a dynamic configuration system that allows logging targets, rules, and layouts to be updated via XML or programmatic

Guzzle is a PHP HTTP client used for sending synchronous and asynchronous requests to web services. It serves as a concurrent HTTP request manager, an HTTP stream handler, and a middleware-based HTTP pipeline. The project is a PSR-7 compliant client, utilizing standardized PHP interfaces for requests, responses, and streams. The library differentiates itself through a customizable functional handler stack that allows for the interception and modification of the request and response lifecycle. It features an adapter-based transport system that enables swapping between network implementations,

CodeIgniter is a PHP web framework built on the Model-View-Controller pattern, designed for building full-stack web applications. It provides a lightweight toolkit with minimal configuration, organizing application logic into controllers, models, and views for clean separation of concerns. The framework includes a fluent query builder for constructing SQL statements programmatically, PSR-4 autoloading with namespace mapping, and a service-based dependency injection container for managing shared class instances. The framework distinguishes itself through its comprehensive set of built-in tools

This project is a JavaScript error tracking SDK and application performance monitoring tool. It captures runtime exceptions and crashes across web browsers, server-side environments, and edge computing contexts. The SDK includes a session replay tool that records visual user interactions to reproduce bugs. To ensure telemetry delivery, it provides a tunneling proxy that routes monitoring data through custom endpoints to bypass browser-level ad blockers. The toolkit also features a source map processor that translates minified stack traces back into original source code. Additionally, it cove

The GitHub ToolKit for developing GitHub Actions.

Logan is a cross-platform mobile logging framework that collects, stores, and uploads client-side logs from iOS, Android, Web, and Flutter environments for centralized debugging and analysis. It provides a complete pipeline from client-side log buffering and file-based local storage through to server-side ingestion and a visual browser for inspecting parsed logs. The system uses a structured binary protocol to encode log entries with content, type, timestamp, and thread metadata, enabling consistent parsing across platforms. A log receiving server handles uploaded files, while a web-based int

This project is a microservice framework for building scalable backend systems in Go. It provides an architecture for distributed systems with integrated support for service discovery, load balancing, and fault-tolerance mechanisms. The framework distinguishes itself through a domain-driven layered architecture and a remote-first configuration system that synchronizes settings between remote stores and local files with automatic failover. It implements a high-performance communication model using gRPC for unary and streaming data exchange, as well as real-time notification systems for managin