qunarcorp/bistoury
Bistoury
Bistoury is a production diagnostics tool for Java applications that provides a distributed debugging console, a performance profiler, and a runtime bytecode manipulator. It enables real-time application debugging and production diagnostics by analyzing running Java applications through dynamic instrumentation and state inspection.
The system distinguishes itself through a remote agent manager that coordinates diagnostic connections and a runtime bytecode manipulator capable of redefining classes in memory without requiring process restarts. It features a web interface for capturing heap dumps, thread stacks, and local variables across multiple server instances, supported by a proxy-mediated communication layer to route commands to remote targets.
The project covers a broad range of observability capabilities, including CPU performance profiling via asynchronous stack sampling and flame graphs, distributed log management across multiple machines, and non-blocking state capture using conditional breakpoints. It also includes source recovery utilities that link runtime bytecode to original source code through decompilation or integration with Git and Maven repositories.
The tool provides a web console and command-line interfaces for managing logs, retrieving system files, and inspecting system configuration and environment variables.
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.
Star history
How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.
