btraceio/btrace

Features

• Java Instrumentation Frameworks - Provides a complete framework for building and deploying Java agents that perform bytecode-level instrumentation.
• JVM Instrumentation Toolkits - Provides a toolkit for injecting and executing custom logic into a running Java Virtual Machine without requiring a restart.
• Runtime Agent Attachment - Provides the ability to attach an instrumentation agent to a live Java Virtual Machine process without restart.
• Method Execution Tracking - Captures method entry, exit, and return values to analyze timings and track execution flow.
• AI Agent Integrations - Connects external AI agents and language models to live JVM runtimes using the Model Context Protocol.
• Model Context Protocol Integrations - Connects Java virtual machines to AI assistants using the standardized Model Context Protocol for automated diagnostics.
• MCP Protocol Integrations - Implements the Model Context Protocol to expose JVM diagnostic operations and tracing tools to AI assistants.
• Model Context Protocol Servers - Implements a Model Context Protocol server to expose JVM diagnostic tools to AI assistants.
• Runtime Process Attachers - Enables attaching to and modifying live JVM processes via instrumentation APIs for real-time monitoring.
• JVM Profiling Tools - Profiles JVM performance by measuring method latency and tracking object allocations.
• Method Execution Trackers - Monitors the duration and output of specific Java methods at runtime using class and method patterns.
• Runtime Code Injection - Enables the insertion of tracing logic into a live process without requiring a restart.
• JVM Agent Communication - Establishes a high-performance binary communication link between a local client and a remote JVM agent.
• Instrumentation Safety Analysis - Analyzes instrumentation scripts at compile time to block unstable patterns like infinite loops or excessive allocations.
• Bytecode Instrumentation Agents - Modifies compiled bytecode at runtime to inject monitoring logic at method entry, return, and exception points.
• Dynamic Instrumentation Injections - Injects tracing scripts into running JVM processes to modify and monitor behavior without restarts.
• Method Interception Proxies - Implements dynamic method interception to inject custom behavior into function calls without altering source code.
• Dynamic Tracing Tools - Acts as a dynamic tracing tool for injecting safe instrumentation scripts into running JVMs.
• Live Process Code Injection - Injects and executes compiled scripts into an active JVM process to extract internal state without termination.
• Application Performance Profiling - Measures method execution durations and analyzes call stacks to identify bottlenecks in live Java applications.
• LLM Interfaces - Exposes runtime diagnostic operations to language models through a common protocol for simplified troubleshooting.
• Method Performance Profiling - Measures execution time for specific methods and filters results to identify performance bottlenecks.
• Agent Packaging - Packages tracing extensions into self-contained JAR files for deployment across distributed environments like Kubernetes.
• Ad-hoc Trace Executions - Runs short command-line scripts to print, count, or time events for rapid debugging.
• Runtime Call-Stack Capturers - Captures active execution frames to identify the sequence of method calls leading to an event.
• Runtime Value Capture - Captures function arguments, return values, and execution durations during runtime instrumentation.
• Isolated Service Interfaces - Enables development of injectable service interfaces that maintain classloader isolation.
• Instrumentation Extension Packaging - Bundles tracing logic into artifacts while automatically inferring the system permissions required for execution.
• Classloader Isolation - Uses isolated Java class loaders to prevent dependency conflicts between tracing extensions and the target application.
• Agent Functionality Extensions - Supports extending the agent's capabilities via a stable API and isolated implementation modules.
• Agent JAR Bundling - Packages instrumentation extensions into a single, self-contained JAR file for simplified deployment in distributed environments.
• Binary Communication Protocols - Uses a high-performance binary serialization and transport protocol for communication between client and agent.
• Custom Event Production - Creates custom recording events to leverage high-performance native Java Flight Recorder recording engines.
• Event Aggregators - Summarizes multiple execution events into totals and averages to identify performance patterns.
• Startup Instrumentation - Allows agents to be pre-loaded at startup to capture events from the earliest stages of the application lifecycle.
• Startup Agent Bootstrapping - Starts applications with a pre-loaded agent to ensure instrumentation is active from the earliest launch stages.
• Thread-Local State Management - Stores independent data copies for each thread to track state across different instrumentation handlers.
• Execution Trace Streams - Routes execution data and structured spans from the instrumented process back to a client for real-time display.
• Exception Traceback Capture - Captures full stack traces automatically when exceptions occur during JVM execution.
• Plugin Installation and Management - Provides a system for installing and managing plugins that expand the agent's functionality.
• Memory Usage Analysis - Calculates the size of specific objects and monitors heap and non-heap consumption at runtime.
• Latency Histograms - Records duration distributions and statistics using histograms to track method execution timing.
• Thread-Local Storage - Maintains ephemeral data associated with specific threads to share state across multiple instrumentation handlers.
• Data Access Tracing - Intercepts and monitors reads and writes to specific object fields and arrays during JVM runtime.
• Lifecycle Startup Tracing - Instruments the application before its main code executes to capture early lifecycle events.
• Execution Event Sampling - Captures a representative subset of runtime events to minimize the performance overhead of tracing.
• Execution Sampling Filters - Reduces instrumentation overhead by capturing only a fraction of method invocations based on sampling rates.
• Ad-hoc Diagnostic One-liners - Allows executing concise command-line scripts to perform quick debugging tasks like counting invocations or filtering slow methods.
• Field Access Tracking - Intercepts reads and writes to specific object fields to monitor state changes in real-time.
• JFR Event Producers - Creates and emits custom Java Flight Recorder events from dynamic instrumentation probes for native performance analysis.
• Dynamic Probe Toggles - Allows toggling sets of instrumentation probe handlers at runtime to adjust diagnostic detail.
• Probe Lifecycle Management - Allows users to list, trigger events for, and remove active instrumentation probes at runtime.
• Trace Exporters - Exports recorded execution event streams into standard formats for external visualization and performance analysis.
• Stack Trace Capturers - Records the sequence of method calls to diagnose execution paths via active thread stacks.
• Object Allocation Profilers - Samples object allocations and aggregates thread stacks to identify hot paths in the target environment.
• Performance Distribution Analyzers - Computes and prints statistical distributions of numeric values to analyze method execution latencies.
• Safe Tracing Constraints - Enforces safety constraints on runtime scripts to prevent loops and allocations that could crash production applications.
• Trace Event Filters - Provides conditional logic to filter trace events and reduce noise in the output.

Star history