psc is a CLI tool that uses eBPF iterators to scan processes and file descriptors with Google CEL for filtering. It provides container context for processes by integrating with Docker, containerd, CRI-O, and Podman runtimes. The architecture is modular with separate packages for BPF data unmarshaling, container management, CEL filtering, and output formatting (table/tree). Key strengths include its efficient kernel-level access via eBPF, expressive CEL-based filtering, and intelligent container context propagation to child processes.
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.
ThinkWatch is a Rust workspace implementing an AI gateway platform that fronts multiple model providers and MCP (Model Context Protocol) servers. It exposes OpenAI-compatible chat/completion endpoints, streaming, MCP tool-call routing, content filtering, and provider failover. The backend is split into crates: `common` (shared lifecycle/limits/access), `auth` (PoW login, API keys), `gateway` (model routing), `mcp-gateway` (MCP server proxying), `server` (REST admin/audit/trace endpoints), and `test-support` (integration test client). A React/TypeScript frontend in `web/` provides an admin console, setup wizard, limits panels, and MCP server management. Data flows: requests enter the gateway, pass through `check_limits`, `check_budget`, `check_access`, then `run_post_invoke`; `trace_id` is propagated across gateway, MCP, audit, and app logs stored in ClickHouse; Postgres holds users, API keys, budgets, and MCP server configs; Redis/Lua scripts enforce rate limits.
This is a large TypeScript monorepo for Sourceloop, a LoopBack 4-based microservices platform for building multi-tenant enterprise SaaS applications. It contains 14+ pre-built microservices covering authentication, audit, notification, chat, scheduler, payment, survey, search, video-conferencing, BPMN/workflow, task management, reporting, feature toggles, OIDC, and user-tenant management. Each service is packaged as a pluggable LoopBack component with controllers, models, repositories, providers, and database migrations for both PostgreSQL and MySQL. The repo also includes reusable cross-cutting packages for caching, observability, file uploads, feature flags, and a CLI for scaffolding new microservices and UI projects, plus many sandbox example applications demonstrating real-world integrations.
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.
EGO is a Go microservices framework designed around component-based lifecycle management. It provides servers (HTTP via Gin, gRPC), clients (HTTP, gRPC), scheduled tasks (cron, one-off jobs), and built-in observability (structured logging, Prometheus metrics, OpenTelemetry tracing). The framework uses a configuration-driven pattern (Load → Build) and includes protoc plugins for generating error types, HTTP handlers, and test scaffolding. Production usage typically involves defining components in TOML/YAML config files and wiring them via the ego.New().Serve(...) entry point. The architecture is modular with clear abstractions for configuration, logging, metrics, registry, and resilient interceptors.
This repository is the web-based user interface for the Google Agent Development Kit (ADK). It functions as a comprehensive IDE and debugging console for building, running, and evaluating AI agents. The application is built on Angular (v21.0.0) using Standalone Components and Signals, serving as a client to a backend agent runtime. Key capabilities include a visual workflow builder for agent graphs, real-time chat interfaces supporting text/audio/video streaming, OpenTelemetry trace ingestion and visualization, and a structured evaluation framework for agent performance metrics. It acts as the control plane for agent execution, handling configuration via YAML and managing session state through WebSocket and HTTP communication.
Wavefront is an enterprise AI middleware platform, open-source alternative to tools like UnifyApps and n8n. It provides a full-stack system for building, managing, and deploying AI agents, chatbots, voice agents, knowledge bases (RAG), and AI-powered workflows. The monorepo includes a Python FastAPI backend with a modular, domain-driven architecture (agents, tools, knowledge base, voice, triggers, auth, API proxy), a React/TypeScript management console, background workers (Celery, stream processors), and the `flo_ai` Python agent framework (LLM wrappers, Arium graph engine, tool system). The platform supports multi-tenancy, RBAC, cloud storage abstractions (GCP/AWS/Azure), and pluggable datasource and authenticator modules. While primarily an application, it incorporates RAG pipelines, image embedding services, and model inference, giving it a hybrid character with strong data engineering elements.
This repository contains a collection of AWS Lambda extension examples and demonstrations across multiple programming languages (Go, Python, Node.js, Java, C#, Rust) and wrapper scripts (Bash, Python, Ruby). Each example illustrates how to build a Lambda extension that integrates deeply with the Lambda execution environment using the Extensions API for lifecycle event registration, and the Logs API/Telemetry API for observability data processing. The extensions perform tasks such as forwarding logs to external destinations (S3, Kinesis, Firehose, Elasticsearch, etc.), collecting and sending telemetry data, implementing custom runtime behavior via wrapper scripts, and caching data from AWS services like DynamoDB and Parameter Store. The repository serves as a practical guide for developers to understand and implement Lambda extensions for observability, security, and governance use cases.
This repository is the official Helm chart distribution hub for Grafana's observability stack, containing over 20 charts for deploying Loki, Tempo, Mimir, Promtail, Grafana Agent, enterprise metrics/logs, and supporting components (rollout-operator, pdc-agent, snyk-exporter, etc.) on Kubernetes. The codebase is entirely Helm templates, values files, CRDs, and CI/CD scripts—no application source code. The architecture follows standard Helm patterns with per-component subdirectories, shared helpers, and extensive use of conditional logic for enterprise features, scaling, and storage backends. Many charts are deprecated or have their source maintained in separate product repositories (e.g., grafana/loki, grafana/tempo), with releases still published here. The repository shows signs of technical drift (old API versions, duplicated template logic, legacy dependencies) but remains actively maintained for the remaining non-deprecated charts with recent CI updates and release automation. It serves as both a legacy archive and an active distribution point.
This repository provides a comprehensive CLI toolkit and programmatic interface (Python SDK and notebook clients) for creating, deploying, managing, monitoring, and evaluating AI agents on Amazon Bedrock AgentCore. The system supports multiple agent frameworks (Strands, LangChain/LangGraph, CrewAI, AutoGen, OpenAI Agents, Google ADK) and infrastructure-as-code options (CDK, Terraform). Key capabilities include project scaffolding via Jinja2 templates, runtime lifecycle management (configure, launch, destroy, invoke), memory management (short-term/long-term, semantic, user preference), observability (CloudWatch-based trace and log querying with OpenTelemetry span parsing), evaluation (LLM-as-a-judge with built-in and custom evaluators), policy engine CRUD, gateway management (MCP, API key, Cognito OAuth), and identity federation setup. The codebase is well-structured with a clear three-layer architecture (CLI -> operations -> services), extensive test coverage, and consistent error handling. However, the project is explicitly deprecated in favor of the @aws/agentcore NPM CLI, meaning future development is minimal and users are encouraged to migrate. Despite the deprecation, the reusable abstractions (e.g., CloudWatch query builder, trace processor, strategy models, configuration schemas) demonstrate solid software craftsmanship.
This repository hosts the source code for '深入高可用系统原理与设计' (Deep dive into high availability system principles and design), a technical book covering system architecture, networking, distributed systems, and cloud-native technologies. The content is organized as a VuePress documentation site, transforming markdown files into a navigable web book with features like dark mode toggle, star tracking, and comment integration. The application architecture follows a standard VuePress static site generator pattern: markdown content is processed through VuePress with custom plugins and styling to produce a deployable static website. Key components include a customized layout that adds book-specific elements (purchase QR code, star counter) and implements reactive dark mode detection using MutationObserver. The site is built and deployed via GitHub Actions to an Aliyun server. While the repository excels in content organization and documentation clarity, the underlying VuePress implementation shows some technical drift due to reliance on outdated release-candidate versions of core dependencies. Nevertheless, it demonstrates solid engineering practices in its customizations, particularly in the reusable styling enhancements found in .vuepress/styles/index.scss which address documentation-specific needs like image centering, responsive content width, and print optimization.
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.
Stan's Robot Shop is a polyglot microservice application designed as a sandbox for learning container orchestration and monitoring. The system comprises eight services (user, catalogue, cart, payment, shipping, ratings, dispatch, web) each built with a different technology stack (Node.js, Java, Python, Go, PHP) and communicating via HTTP or RabbitMQ. Data is persisted in MongoDB (catalogue, user), Redis (cart, session), and MySQL (shipping, ratings). The application provides Docker Compose and Kubernetes manifests for deployment, along with Instana integration for automatic tracing and metrics collection. While the application successfully demonstrates microservice patterns and technology diversity, the codebase exhibits significant technical drift due to outdated dependencies (e.g., Express 4.15, Redis 2.8, Spring Boot 2.3) and lacks modern practices such as comprehensive error handling and security measures. The architecture is modular and service boundaries are clear, but the implementation relies on boilerplate for tracing and health checks. A notable reusable component is the Haversine distance calculator in the shipping service, which is isolated and dependency-free.