Apache SkyWalking is an open-source APM (Application Performance Monitoring) system designed for microservices, cloud-native, and container-based architectures. It provides distributed tracing, metrics aggregation, log analysis, and profiling capabilities (including eBPF, async-profiler, and JFR). The system features a modular, plugin-based architecture where receivers ingest telemetry data, analyzers process it, storage plugins persist it, and query services expose it via GraphQL, PromQL, LogQL, and TraceQL interfaces. Alarm mechanisms detect anomalies and trigger notifications through multiple channels. The codebase demonstrates strong engineering practices with clear separation of concerns, extensive use of interfaces and dependency injection, and reusable patterns like the module system, storage abstraction, and analysis listener framework.
highlight.io is an open-source, full-stack observability platform that provides session replay, error monitoring, logging, distributed tracing, and metrics dashboards. The system is architected as a monorepo with a Go backend (serving GraphQL APIs via gqlgen), a React/TypeScript frontend (using Vite, Apollo Client, and a custom UI component library), and SDKs for over a dozen languages and frameworks (JavaScript/TypeScript, Go, Python, Ruby, Java, Rust, Elixir, .NET, etc.). Data is ingested via OpenTelemetry (OTLP) and custom SDKs, processed through Kafka queues, stored in ClickHouse for analytics and PostgreSQL for relational data, with Redis caching and S3 for session replay assets. The platform includes alerting (Slack, Discord, Microsoft Teams, webhooks), integrations with GitHub, Jira, Linear, Vercel, and more, as well as AI-powered features like session insights and error grouping. The primary entry points are the frontend SPA (routed via React Router) and the backend GraphQL endpoints (private-graph for authenticated users, public-graph for data ingestion). Key data flows include: browser SDK capturing session events and errors → public-graph → Kafka → ClickHouse/Postgres; server SDKs sending logs/traces/metrics via OTLP → OpenTelemetry collector → ClickHouse; and background workers (Lambda functions) for digests, session exports, and alert evaluations. The system is designed for both cloud-hosted and self-hosted deployments (Docker Compose, AWS ECS). While primarily an application, the repository contains significant data engineering components: ClickHouse materialized views for aggregations, Kafka for stream processing, and custom query parsing (ANTLR grammar) for search across logs, traces, and sessions. The codebase demonstrates high craftsmanship with a well-structured monorepo, extensive testing (Go unit tests, e2e tests across frameworks), and a reusable UI component library. However, the large number of SDKs and integrations introduces maintenance complexity, and some legacy patterns (e.g., coexistence of old and new dev tools) indicate ongoing refactoring.
HyperDX / ClickStack is a full-stack observability platform for ingesting, storing, querying, and visualizing logs, traces, metrics, and session replays. The system is architected as a monorepo with a Next.js frontend (React, Mantine, CodeMirror, Recharts), an Express.js API backend (MongoDB metadata, ClickHouse primary data store), a CLI tool (ink-based TUI), and an OpenTelemetry collector for ingestion. Key capabilities include real-time dashboards with drag-and-drop tile layout, multi-channel alerting (webhook, Slack, incident.io), advanced search with Lucene and SQL, log pattern mining (Drain algorithm), session replay, service maps, Kubernetes monitoring, and a Model Context Protocol (MCP) server that exposes observability tools to AI assistants. The platform supports authentication via local accounts or OIDC, OpAMP agent configuration, and includes an evaluation framework (hdx-eval) for benchmarking agent performance on SRE scenarios. Although the repo is primarily an application, it contains data-intensive components like the log miner and analytics query engines that cross over into data engineering territory.
This repository provides TransmittableThreadLocal (TTL), a Java library that extends InheritableThreadLocal to propagate thread-local values across threads even when using thread pools, executors, ForkJoinPool, and other asynchronous constructs. It solves the common problem of context loss (e.g., tracing, security, session) in asynchronous Java applications. The library offers three usage modes: manual wrapping of Runnable/Callable via TtlRunnable/TtlCallable, wrapping executors via TtlExecutors, and transparent bytecode transformation via a Java Agent (TtlAgent) that automatically instruments JDK thread pool classes. The architecture is modular: ttl-core contains the core API and CRR (Capture-Replay-Restore) pattern, ttl-agent provides the agent with Javassist-based transformlets, ttl-kotlin adds Kotlin extensions, and ttl-integrations includes Vert.x 3/4 support. A ttl2-compatible module maintains backward compatibility with the v2 API. The library is widely adopted in the Java ecosystem (e.g., Apache ShardingSphere, SOFARPC) and is under active development with a v3 branch introducing a refined API. While primarily a library, it includes a Java Agent component that operates at the JVM level, making it a hybrid of library and instrumentation tool.
Sentry is a full-stack application for error monitoring, performance tracing, session replay, and observability. In production, it ingests events (errors, transactions, logs, replays, profiles) from SDKs via a Relay proxy, processes them through Kafka streams, and stores data in ClickHouse (Snuba) and PostgreSQL. It exposes a REST API (Django REST Framework) and a React frontend for dashboards, issue management, alerts, and AI-powered features (Seer). The architecture is a monolith with hybrid-cloud services: a control silo for global state, cell silos for regional data, and an API gateway. Key entry points include the Relay ingestion endpoint, the Django WSGI/ASGI server, and Celery task workers. External dependencies include PostgreSQL, ClickHouse, Kafka, Redis, and cloud providers (GCP, AWS). The codebase also includes a billing/subscription layer (getsentry) and extensive third-party integrations (Slack, GitHub, Jira, etc.).
SigNoz is a full-stack open-source observability platform that ingests OpenTelemetry data (traces, metrics, logs), stores it in ClickHouse, and provides a rich web UI for querying, dashboards, alerts, and infrastructure monitoring. The backend is written in Go with a modular architecture using factory/provider patterns, SQL migrations, and OpenFGA-based authorization. The frontend is a React/TypeScript SPA with Zustand state management, react-query, uPlot charts, and a comprehensive query builder supporting PromQL, ClickHouse SQL, and builder queries. The enterprise edition adds anomaly detection, RBAC, licensing, and usage metering. The codebase is actively maintained with extensive testing (unit, integration, e2e) and CI/CD, though some legacy API versions and deprecated clients indicate ongoing migration.
This repository contains the Apache SkyWalking Nginx Agent, a Lua-based library that provides distributed tracing capabilities for Nginx and OpenResty deployments. The agent integrates with Nginx's Lua API to automatically trace incoming and outgoing HTTP requests, propagate trace context between services using custom headers (sw8 and sw8-correlation), and report trace data to a SkyWalking OAP server. The architecture uses Nginx's phased execution model (init_worker, rewrite, body_filter, log) to manage the tracing lifecycle, with a shared dictionary for buffering trace segments and a timer for periodic reporting and heartbeats. The codebase demonstrates strong engineering practices with clear separation of concerns, comprehensive error handling, and performance optimizations like table pooling to reduce garbage collection pressure in LuaJIT. Several components show particular craftsmanship and reusability: the utility module provides high-performance table pooling and ID generation; the correlation context module implements lightweight context propagation via base64-encoded headers; and the segment reference module handles trace context serialization for cross-process tracing.