The OpenAI Agents SDK (Python) is a production-grade library for building agentic AI applications. It provides a complete agent runtime (`Runner`, `Agent`, `RunConfig`) with support for tool calling, handoffs, guardrails, sandboxed execution (Docker, Modal, E2B, Cloudflare, Vercel, Unix-local), realtime voice/audio pipelines, MCP integration, and multi-provider model routing (OpenAI, LiteLLM, AnyLLM, custom). The codebase is async-first with extensive tracing/observability, session persistence (SQLite, OpenAI Conversations, Responses Compaction), and a rich lifecycle-hook system. It includes a large test suite covering unit, integration, and sandbox security scenarios, plus internal tooling skills for release management and code review. The SDK is actively maintained with a 0.23.x version, release automation via release-please, and comprehensive docs in English and Japanese.
Langfuse is an open-source LLM observability and evaluation platform. It provides tracing, prompt management, evaluations, datasets, experiments, monitors, and a public API for integrating with AI applications. The architecture is a monorepo with pnpm workspaces and Turborepo, consisting of a Next.js frontend (web), a background worker (Express + BullMQ), a shared package with types and server utilities, and an enterprise edition. Data flows from ingestion (REST API, OpenTelemetry, SDKs) into ClickHouse for high-volume analytics and PostgreSQL for relational metadata. Background jobs handle evaluations, batch exports, cloud billing, and integrations. The codebase is well-structured with extensive testing, a custom ESLint plugin, and reusable UI components. It is actively maintained with frequent migrations and feature additions.
This is the OpenTelemetry Collector Contrib repository, a large collection of community-maintained components (receivers, processors, exporters, extensions, connectors) for the OpenTelemetry Collector. It provides a pluggable telemetry pipeline for traces, metrics, logs, and profiles. The architecture is a multi-module Go monorepo where each component follows a consistent factory pattern with generated metadata (via mdatagen). Key entry points include component factories (NewFactory), configuration structs with Validate methods, and lifecycle hooks (Start, Shutdown). Data flows involve receiving telemetry from diverse sources (e.g., Prometheus, Kafka, cloud APIs, databases), processing (transformation via OTTL, filtering, sampling, resource detection), and exporting to backends (e.g., Elasticsearch, Datadog, AWS S3, ClickHouse). External dependencies include cloud provider SDKs, database drivers, messaging libraries, and the core OpenTelemetry Collector SDK. The codebase is well-structured with extensive unit and integration tests, benchmarks, and fuzz tests. It demonstrates high craftsmanship in areas like the OTTL transformation language, the Stanza log processing pipeline, and the resource detection processor with cloud-specific detectors. Many components are reusable as standalone libraries (e.g., pkg/ottl, pkg/stanza, pkg/expohisto). The repository is actively maintained with frequent commits, CI/CD pipelines, and a clear governance model. While some components are in alpha or deprecated, the overall quality is high and the patterns are consistent.
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.
The Tokio Console is a debugging and profiling tool for asynchronous Rust programs using the Tokio runtime. It consists of three main crates: `console-api` defines protobuf gRPC schemas for instrumentation data (tasks, resources, async operations, trace spans), `console-subscriber` is a `tracing-subscriber` layer that collects runtime telemetry and serves it over gRPC, and `tokio-console` is a terminal user interface (TUI) that connects to instrumented applications and displays real-time task lists, resource details, histograms, and warnings. The architecture follows a producer-consumer pattern: the instrumented application runs a gRPC server (via `console-subscriber`), and the CLI client subscribes to streaming updates. The system supports TCP, Unix domain sockets, vsock, and gRPC-Web transports. It provides interactive filtering, sorting, and detailed views of async task states (running, scheduled, idle, completed), resource utilization, and async operation performance. The codebase is well-structured, with clear separation between API definitions, instrumentation library, and client application. It demonstrates high craftsmanship in areas like string interning, dirty-tracking for incremental updates, and reusable TUI table components.
Aya is a Rust framework for developing, loading, and managing eBPF (extended Berkeley Packet Filter) programs. It provides a pure-Rust alternative to libbpf and bcc, allowing developers to write eBPF programs in Rust without leaving the language ecosystem. The framework supports various eBPF program types (XDP, socket filters, tracepoints, kprobes, uprobes, LSM, etc.) and map types (arrays, hash maps, perf event arrays, ring buffers, etc.), with strong emphasis on type safety and developer experience. Aya implements BTF (BPF Type Format) support for compile-once-run-everywhere portability across kernel versions and provides procedural macros to reduce boilerplate when defining eBPF entities. The architecture consists of multiple crates separating userspace and kernel-space concerns, with extensive integration tests validating functionality against actual kernels.
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.
Trice is an embedded logging and tracing toolchain consisting of a lightweight C instrumentation library for microcontrollers and a Go-based host CLI tool. The C library provides variadic macros that emit compact binary records (ID + values) instead of format strings, drastically reducing flash and bandwidth usage. The Go tool manages Trice IDs (insert, clean, bind), decodes incoming binary streams from targets over UART, RTT, TCP/UDP, or file, and displays formatted logs with timestamps, colors, and filtering. It supports multiple buffer strategies (stack, static, double, ring), framing protocols (COBS, TCOBS), optional XTEA encryption, and local logging on the target itself. The architecture is a classic host-target split: the target runs the C library, the host runs the Go CLI. The codebase is well-tested with a large matrix of CGO test configurations and CI pipelines for multiple STM32 example projects. It is actively maintained with frequent releases and a responsive issue tracker.
This repository implements OpenTelemetry eBPF Instrumentation (OBI), a production-grade observability agent that uses eBPF to automatically capture distributed traces, metrics, and logs from user-space applications without any code changes. It supports a wide range of protocols (HTTP/1.1, HTTP/2, gRPC, SQL, Redis, Kafka, MongoDB, AMQP, MQTT, DNS, and more) and multiple language runtimes (Go, Java, Python, Node.js, Ruby, .NET, Rust). The agent can run as a standalone binary, a Docker container, or an OpenTelemetry Collector receiver. Its architecture consists of eBPF programs (kprobes, uprobes, tracepoints, TC) that emit events to ring buffers, which are read by Go userspace tracers and processed through a pipeline of discovery, decoration, filtering, and export stages. Telemetry is exported via OTLP (gRPC/HTTP) or Prometheus, with optional Kubernetes metadata enrichment and network flow monitoring. The codebase is well-structured with clear separation of concerns, extensive integration tests, and several reusable generic components (message queues, pipeline runners, expiry caches, attribute filters). It is actively maintained with frequent commits and comprehensive CI/CD.
go-instrument is a CLI tool that automatically instruments Go source files with OpenTelemetry trace spans. It parses Go AST, identifies functions that accept a `context.Context` parameter, and inserts span creation, defer, and optional error recording statements. It handles various edge cases: anonymous functions, build constraints (ignore/exclude), generated files, custom context/error parameter names, already-instrumented functions, and preserves original line numbers for panic stack traces via compiler directives. The tool is implemented as a reusable library with a clear separation between the generic AST processing engine (`processor` package) and the specific instrumentation strategy (`instrument` package), allowing custom instrumenters. The CLI frontend is minimal; the core logic is in the `processor` and `instrument` packages and is cleanly abstracted via an `Instrumenter` interface. The codebase is well-tested, includes fuzz testing, and uses current Go tooling.
This is the official Sentry SDK for PHP (sentry-php), a client library that instruments PHP applications for error tracking, exception capture, performance monitoring (tracing, logging, metrics, profiling, and check-ins). The architecture follows a hub-scope pattern: a global SentrySdk facade manages a stack of Hub instances, each holding a Client and Scope. The Client handles event creation, before-send callbacks, sampling, and integration setup. Events are serialized into Sentry envelope format and transmitted via an HTTP transport (cURL) or a local agent socket. The library ships with numerous integrations for PHP frameworks (Monolog, Guzzle, OpenTelemetry, Symfony, Laravel), a custom Options resolver, serializers, aggregation buffers for metrics and logs, and runtime context isolation for long-lived workers (FrankenPHP, RoadRunner). External dependencies include Monolog, PSR-7, OpenTelemetry API, and the Excimer extension for profiling. The SDK is highly configurable via the Options class and supports extensive event enrichment through scopes and event processors.
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.
file.d is a high‑throughput log and event processing daemon written in Go, designed for production data pipelines. It reads events from various sources (files, Kafka, Kubernetes, HTTP, syslog, sockets, journalctl), runs them through a configurable chain of action plugins (masking, throttling, transformation, decoding, joining, etc.), and delivers them to multiple outputs (Elasticsearch, ClickHouse, Loki, S3, Kafka, Splunk, Postgres, GELF, file, stdout). The architecture is plugin‑based: inputs, actions, and outputs register into a central registry, and pipelines are defined via YAML configuration. The system provides at‑least‑once delivery semantics, stream‑based ordering, batching with backoff, and dead‑queue failover. The codebase demonstrates strong engineering practices: extensive unit and integration tests (including e2e scenarios with external services), performance optimizations (zero‑copy JSON via insane‑json, event pooling, memory limits), and a rich set of reusable internal libraries (HTTP client with circuit breaker, metric controllers, match rules, configuration parsing). It includes a Helm chart for Kubernetes deployment, Prometheus monitoring with a Grafana dashboard, and a playground web service for interactively testing pipelines. The transform action includes a custom expression language with a Pratt parser and compiler. While the core is solid, there are some maintenance risks: many plugins contain global caches or mutable state, several code paths call `logger.Fatal` on misconfiguration (making the whole process exit), and the file input offset persistence is hand‑rolled. The large number of input/output/action plugins (~40 total) increases surface area for drift, and some e2e tests depend on external Docker services. Overall, file.d is a mature and capable data pipeline framework, well‑suited for log aggregation and transformation in containerized environments.
TraceAI is a multi-language (Python, TypeScript, Java, C#) OpenTelemetry-based instrumentation SDK for AI/LLM applications. It provides drop-in auto-instrumentation for 50+ LLM providers, agent frameworks (LangChain, LlamaIndex, CrewAI, AutoGen, etc.), and vector databases (Pinecone, ChromaDB, Qdrant, etc.). The core library wraps SDK calls to capture structured spans with semantic attributes (tokens, model, messages, tool calls) and exports them via OTLP to any OpenTelemetry-compatible backend, with a default hosted backend at Future AGI. The architecture is a monorepo with per-framework packages that follow a consistent instrumentor pattern: register a tracer provider, instrument the target library, then make API calls. Key entry points are `register()` (Python/TypeScript), `TraceAI.init()` (Java), and `TraceAI.Register()` (C#). The SDK also includes context attribute propagation, PII redaction, evaluation tags, and configurable masking. While the codebase is well-structured and actively maintained, there is significant duplication across framework instrumentors and some tests rely on heavy mocking, which limits reusability of individual components.
Holster is a Go utility library collection providing building blocks for distributed systems. It offers deterministic time control for testing, leader election implementations (etcd-based and Raft-inspired), enhanced error handling with context and stack traces, service discovery (Consul, DNS SRV), OpenTelemetry tracing, caching mechanisms (LRU, TTL, ExpireCache), retry utilities, HTTP request signing, gRPC connection pooling, and MX record resolution. Designed as drop-in replacements for standard library components with enhanced functionality, it focuses on solving common infrastructure challenges in microservices architectures. The library maintains a clear separation of concerns with each package addressing a specific cross-cutting concern.
This repository is a Nuxt.js 2 module that integrates Sentry error tracking into Nuxt applications. It provides client-side and server-side Sentry initialization, lazy loading, performance tracing, release management, and extensive integration configuration. The module hooks into Nuxt's build process via a custom shim for @nuxt/kit, generating plugin templates and configuring webpack. It supports both JavaScript and TypeScript projects, with options for custom integrations and runtime configuration. The codebase is well-structured with clear separation of concerns (module entry, hooks, options resolution, utilities, templates) and includes a comprehensive test suite using vitest and playwright. However, it is specifically designed for Nuxt 2, which is now deprecated, and the official Sentry Nuxt module is recommended for Nuxt 3+. The repository appears to be in maintenance mode with the last release in September 2024 and no recent commits.
Honey Potion is a compiler framework that translates a subset of the Elixir programming language into eBPF (extended Berkeley Packet Filter) programs, targeting both tracepoints and XDP. The system works as an Elixir library (published on Hex as `honey`) where users write eBPF logic in Elixir using macros like `@sec`, `defmap`, and `fuel`. At compile time, `__before_compile__` triggers a pipeline: static analysis, optimization (constant propagation, dead code elimination, type propagation), AST-to-C translation, boilerplate generation, and C compilation via `make`/`clang`/`llc`/`bpftool`. The generated C code includes a custom runtime with heap, tuple pool, and string pool implemented using BPF maps to overcome eBPF's stack and memory constraints. The repository includes 20+ example programs (system monitors, packet filters, data structure demos) and a comprehensive benchmark suite comparing hand-written C eBPF programs to Honey-generated ones, supporting a published research paper. Although classified as an application (a compiler library), the project has strong research characteristics with reproducible artifact scripts, optimizer variants, and performance comparisons.
This repository is a curated list of OpenTelemetry resources, maintained as a static markdown file (readme.md). It serves as a reference for developers and engineers seeking to learn about OpenTelemetry, including books, videos, blogs, instrumentation guides, and vendor solutions. The repository does not contain any executable code or data processing logic; instead, it organizes external links into thematic sections for easy consumption. The project is actively maintained, with recent commits and community engagement (as indicated by stars, forks, and open issues). It follows standard open-source practices with a license, code of conduct, and contributing guidelines. Technically, there is no drift to assess as the repository consists solely of documentation and configuration files without external dependencies. While the repository lacks reusable software components, its value lies in the curation and presentation of OpenTelemetry knowledge. The markdown structure is clean and navigable, making it a useful starting point for anyone exploring the OpenTelemetry ecosystem.
This repository provides a kernel module for tracing user-space functions using uprobe, along with a user-space tool to clear uprobes. The kernel module hooks into the mincore system call to set up tracing parameters and function probes. It uses a red-black tree implementation to store function information. The module is designed for Android and has been tested on kernel versions 5.10 and 5.15, with claimed support for 6.x kernels. The user-space tool is a simple executable that invokes the mincore system call to clear all set uprobes.