oldmanpushcart/greys-anatomy
Greys Anatomy
This project is a Java runtime diagnostic tool and bytecode instrumentation framework. It provides a remote troubleshooting interface for inspecting live Java systems, analyzing execution traces, and monitoring method performance without requiring application restarts.
The system distinguishes itself through its ability to modify Java classes at runtime to capture parameters and return values, combined with a JavaScript-based scripting engine for custom diagnostic logic. It further supports collaborative live debugging, allowing multiple users to connect to a single remote process simultaneously to share diagnostic sessions.
The tool's broader capabilities include method-level performance metrics, chronological execution history recording, and live state analysis. It provides utilities for call stack capture, runtime environment inspection, and conditional method interception to evaluate dynamic expressions within a running environment.
Features
- Java Diagnostic Toolkits - Provides a comprehensive toolkit for real-time diagnosis of live Java applications via method interception and state inspection.
- Runtime Bytecode Instrumentation - Implements dynamic modification of compiled bytecode during application execution via a runtime agent.
- Runtime Call-Stack Capturers - Extracts active execution frames to determine the trigger source of a specific method call.
- Execution Trace and Log Analyzers - Captures and visualizes historical execution streams and call stacks to reconstruct application behavior.
- Runtime Bytecode Injection - Modifies compiled instructions in memory during execution to insert custom diagnostic logic without restarting the system.
- Class Metadata Inspection - Provides utilities for discovering and analyzing loaded classes and their methods within a running JVM process.
- Class Method Interception - Intercepts methods within specific classes to capture parameters and return values using conditional filters.
- Java Instrumentation Frameworks - Provides a framework to capture execution timing, exceptions, and arguments in Java applications via runtime instrumentation.
- JVM Remote Connection Agents - Provides the fundamental communication link required to connect a remote console to a running JVM.
- Runtime Value Inspections - Allows observation and custom formatting of input parameters and return values for live method calls.
- System and App Trace Recorders - Records and replays method parameters, return values, and exception details to analyze data flow.
- JVM Execution State Analysis - Inspects loaded classes, execution contexts, and stack traces in a running system without requiring a restart.
- Remote Java Troubleshooting - Connects to a running JVM from a remote console to perform simultaneous collaborative troubleshooting of production issues.
- Method Execution Tracking - Monitors the invocation sequence and data flow of specific methods within a running system.
- Application Stack Trace Capturers - Provides utilities for retrieving and analyzing the current execution flow from a target Java program to identify bottlenecks.
- Method Call Profiling - Tracks the frequency and duration of Java method calls for real-time performance analysis and bottleneck identification.
- Call Argument History - Records the history of method input parameters and return values for detailed retrospective data analysis.
- Data Interception - Captures parameters and return values from Java methods at runtime for behavioral analysis.
- Debugging Session Sharing - Allows multiple users to share live diagnostic sessions and execution rules for collaborative troubleshooting.
- Execution History Logs - Logs a chronological timeline of method calls and arguments for retrospective analysis of system state.
- Method Execution Logs - Records every method execution detail chronologically to reconstruct the behavior of the system.
- Embedded JavaScript Scripting - Integrates a JavaScript runtime into the Java application to provide programmable diagnostic logic and dynamic expressions.
- Runtime Component Discovery - Enables finding loaded classes and methods in the JVM using wildcards or regular expressions.
- Diagnostic Scripts - Enables the execution of JavaScript scripts to implement scenario-specific diagnostic logic.
- Dynamic Expression Evaluators - Implements an engine to evaluate scriptable expressions for inspecting detailed attributes of runtime objects.
- Diagnostic Command Interfaces - Provides a command-line interface for executing pre-defined troubleshooting commands to analyze remote systems.
- Trace Recording - Captures and serializes the sequence of method calls and arguments for retrospective analysis.
- Java Runtime Monitors - Tracks real-time performance metrics, call volumes, and response times for specific methods within the JVM.
- Method Call Chain Analysis - Renders the call chain of a method and calculates the time spent at each node in the sequence.
- Method Performance Metrics - Tracks quantitative execution data, including call volume and response times, for specified Java methods.
- Runtime Environment Inspection - Provides utilities to retrieve basic runtime information and details about loaded classes and methods.
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.
