qunarcorp/bistoury
Bistoury
Bistoury es una herramienta de diagnóstico de producción para aplicaciones Java que proporciona una consola de depuración distribuida, un perfilador de rendimiento y un manipulador de bytecode en tiempo real. Permite la depuración de aplicaciones en tiempo real y diagnósticos de producción analizando aplicaciones Java en ejecución mediante instrumentación dinámica e inspección de estado.
El sistema se distingue por un gestor de agentes remoto que coordina conexiones de diagnóstico y un manipulador de bytecode en tiempo real capaz de redefinir clases en memoria sin requerir reinicios de proceso. Cuenta con una interfaz web para capturar volcados de memoria (heap dumps), pilas de hilos y variables locales a través de múltiples instancias de servidor, soportado por una capa de comunicación mediada por proxy para enrutar comandos a objetivos remotos.
El proyecto cubre una amplia gama de capacidades de observabilidad, incluyendo perfilado de rendimiento de CPU mediante muestreo de pila asíncrono y flame graphs, gestión de logs distribuida a través de múltiples máquinas y captura de estado sin bloqueo utilizando puntos de interrupción condicionales. También incluye utilidades de recuperación de fuente que vinculan el bytecode en tiempo real con el código fuente original mediante descompilación o integración con repositorios Git y Maven.
La herramienta proporciona una consola web e interfaces de línea de comandos para gestionar logs, recuperar archivos del sistema e inspeccionar la configuración del sistema y variables de entorno.
Features
- Live Instrumentation - Performs dynamic instrumentation and real-time debugging on active production environments without requiring process restarts.
- Java Diagnostic Toolkits - Provides a comprehensive suite for real-time troubleshooting of live Java applications through dynamic instrumentation and state inspection.
- Java Application Profilers - Identifies CPU bottlenecks and hot methods in running Java applications using flame graphs and asynchronous stack trace analysis.
- System State Snapshotting - Captures point-in-time snapshots of local variables and call stacks at specific code lines without pausing the system.
- Non-pausing State Capture - Snapshots local variables and call stacks at breakpoints without pausing the execution of the active application.
- CPU Profilers - Measures and visualizes CPU usage and execution time through asynchronous stack traces to find processing bottlenecks.
- Application-to-Host Registries - Maintains mappings between logical application names, physical servers, and process IDs for distributed discovery.
- Diagnostic Agent Management - Coordinates the mapping of applications to physical hosts and manages the lifecycle of remote diagnostic agents.
- Dynamic Instrumentation Debugging - Inspects variable values and captures runtime state in active environments using dynamic instrumentation.
- Proxy Routing - Routes diagnostic requests from a central console through a secure proxy layer to remote target agents.
- Dynamic Class Redefinition - Redefines loaded classes in memory at runtime to modify application behavior without process restarts.
- Bytecode Modification Frameworks - Compiles files in memory and redefines loaded classes using external bytecode to modify behavior without restarts.
- Conditional Variable Captures - Triggers state captures of local variables and call stacks only when specific logical expressions evaluate to true.
- Runtime Bytecode Instrumentation - Injects modified class data into a running JVM to monitor execution and capture state dynamically.
- Java Bytecode Manipulation - Enables the modification of loaded Java classes and redefinition of bytecode in memory without requiring process restarts.
- Production Diagnostics - Troubleshoots live production environments using a unified interface for system state monitoring and thread analysis.
- Application Performance Monitoring - Tracks runtime system metrics and identifies resource bottlenecks in live Java applications.
- Diagnostic Web Consoles - Provides a browser interface for diagnostics and logs to avoid direct server shell access.
- Java Heap Snapshot Capturers - Captures heap dumps from running Java processes to identify memory leaks and analyze object allocations.
- Remote Command Execution - Sends troubleshooting commands to target applications via a proxy and agent for real-time results.
- Application State Inspection - Examines running application state and variable values using decompiled code or linked source repositories.
- System Performance Profiling - Captures periodic snapshots of thread call stacks to identify CPU bottlenecks and generate flame graphs.
- Method Performance Profiling - Identifies hot methods and generates flame graphs to analyze execution time and optimize application speed.
- Distributed File Managers - Enables searching and reading files or compressed logs across multiple remote machines via a unified interface.
- Application Configuration Inspection - Retrieves and updates system properties, environment variables, and diagnostic parameters of a running application.
- Debugging Consoles - Provides a web-based console for real-time inspection of heap dumps, thread stacks, and variables across multiple server instances.
- Non-disruptive Monitoring - Adds observability probes to specific methods in a running application without interrupting execution.
- Diagnostic Source Integration - Integrates diagnostic tools with version control systems to display original source code during live analysis.
- Runtime Analysis - Collects operational data, system properties, and machine metrics to analyze the overall health of the JVM.
- Java Bytecode Decompilers - Converts compiled Java class files back into human-readable source code when original files are unavailable.
- Bytecode-to-Source Mapping - Links runtime bytecode execution steps to the original source code lines for real-time debugging.
- Version Control Integration - Links runtime bytecode to specific Git or Maven version hashes to retrieve the original source code.
- Thread Dumps - Generates snapshots of active JVM threads to diagnose deadlocks and concurrency issues.
- Thread Inspection - Inspects thread stacks and analyzes state to resolve lock contention and concurrency issues.
- Class Metadata Inspection - Analyzes loaded classes and their methods within a running process to diagnose runtime issues.
- Classloader Hierarchy Analysis - Visualizes classloader hierarchies and method signatures by analyzing classes loaded in the runtime environment.
- Remote Access Proxies - Routes diagnostic commands from a central console to target servers through a secure proxy isolation layer.
- Call Stack Samplers - Provides periodic call stack snapshots to build statistical CPU profiles and generate flame graphs.
- JMX Bean Inspections - Queries Java Management Extensions MBeans to retrieve and analyze internal runtime state and configuration.
- Log Analysis - Provides tools to search and analyze application logs across multiple remote machines using tail and grep operations.
- Method Call Chain Analysis - Maps the internal call path of methods and calculates the time spent at each node in the chain.
- Method Performance Metrics - Captures quantitative execution data including method call counts, exception rates, and response times.
- Thread Performance Analyzers - Identifies CPU-intensive threads and retains historical call stacks for performance analysis.
- Remote Log Management - Provides a command-line interface to view and download logs from production environments.
- Method Execution Tracking - Monitors the invocation sequence, input parameters, and return values of methods during runtime.
- System Health Dashboards - Displays real-time request rates, response times, and thread pool status on a centralized health dashboard.
- Unified Log Management - Provides a unified interface for searching and retrieving application logs across multiple remote servers.
- Call Argument History - Records and stores the history of method input parameters and return values for retrospective analysis.
