This article walks you through setting up the environment, creating a Spring Boot project, defining strong‑typed domain models, implementing @Action methods, declaring goals, and running an interactive shell so you can build and execute a fully functional Embabel Java Agent that automatically generates a research brief.
Claude Opus 4.8’s new Fast mode, now available in JetBrains IDEs, speeds up the entire Java‑Agent development loop by reducing the waiting periods between analysis, modification, testing and verification, making high‑frequency iterative tasks far more efficient.
This article explains why distributed tracing is essential for Spring Cloud microservices, introduces SkyWalking’s core concepts, compares it with other tracing tools, shows how to deploy SkyWalking via Docker Compose, integrate the Java agent, and use the UI to analyze performance, errors, and alerts.
This article demonstrates how to use Java Agent and the java.lang.instrument API to non‑intrusively measure method execution time, dynamically modify bytecode with ASM, leverage Attach for runtime instrumentation, and explore related tools like Arthas and Bytekit for tracing and debugging Java applications.
This article explains how to build a Spring Boot hot‑patch loader that uses Java agents and dynamic class loading to apply runtime patches—such as Spring Bean, plain class, or static method replacements—allowing urgent bug fixes in production within minutes without restarting the service.
This article explains how the Transmittable ThreadLocal (TTL) Java agent works, why improper usage can cause context contamination, memory leaks, and CPU spikes, and provides real production cases, code examples, and practical recommendations to avoid these pitfalls.
This article walks through the motivation, design, implementation, and best‑practice deployment of a Spring Boot hot‑patch system that lets developers dynamically load and apply patches to beans, classes, and methods in production within minutes, avoiding lengthy release cycles.
This article demonstrates how to extend Spring Boot 3's dependency injection to objects created with the new operator by using AspectJ load‑time weaving, @Configurable, META‑INF/aop.xml configuration, and the required -javaagent, providing step‑by‑step code examples and troubleshooting tips.
This article explains why inserting manual timing code is invasive, introduces the java.lang.instrument API, shows how to write a tiny Java Agent with premain and agentmain methods, demonstrates dynamic class redefinition via the Attach API, and explores how tools like Arthas and Bytekit leverage these mechanisms for runtime tracing and bytecode enhancement.
This article introduces a SpringBoot online debugging injector that lets backend developers add, adjust, and remove fine‑grained debug rules at runtime, eliminating midnight alarm calls, costly redeployments, and performance bottlenecks while keeping production services safe and uninterrupted.
This article explains the pain points of traditional Java backend debugging, compares existing solutions, and presents a SpringBoot zero‑impact online debug injector built with ByteBuddy, Java Instrumentation, and a lightweight Tailwind/Alpine.js UI that enables instant, precise, and secure method‑level debugging in production.
This article explains how Java developers can locate and resolve performance issues by using Skywalking and Arthas together, covering class loading mechanisms, Java Agent instrumentation, bytecode manipulation techniques, and practical command examples for monitoring, tracing, and hot‑spot analysis.
This article explains how to replace invasive timing code with a Java Agent using the Instrumentation API, demonstrates both premain and attach approaches, shows ASM‑based bytecode transformation examples, and explores how Arthas trace leverages similar techniques for runtime monitoring.
Oracle’s March 2025 release of JDK 24 and GraalVM 24 introduces a new Class‑File API and Premain support for Java agents, allowing static compilation of agents, improving observability, reducing native image size, and delivering measurable startup‑time and memory‑usage gains.
This guide walks you through downloading Byteman, setting up BYTEMAN_HOME, using Ant or Maven for integration, building from source, configuring the Java agent with detailed options, and leveraging tutorials for effective fault‑injection testing in Java applications.
This guide explains how to use the bmjava script to launch Byteman with custom options, employ bmsubmit for dynamic rule management, run bmcheck for offline rule validation, configure environment variables, and understand the Byteman agent’s loading lifecycle, providing complete command syntax and option details.
This article explains the challenges of Java cold start and high memory usage in cloud‑native environments, introduces GraalVM static compilation and a novel static Java Agent solution, and provides step‑by‑step instructions for installing ARMS, configuring dependencies, and achieving fast, observable native images.
This tutorial explains Java Agent technology, shows how to implement a custom agent using the Instrumentation API and Javassist, integrates it with a Spring Boot 3 application to log API execution time, and provides step‑by‑step packaging and execution instructions.
This guide explains the challenges of Java cold‑start and high runtime memory in cloud‑native environments, introduces GraalVM static compilation and a novel static Java Agent instrumentation solution, and provides step‑by‑step instructions—including dependency installation, Maven configuration, pre‑run collection, and native image building—to enable observable, high‑performance Java applications.
This article explains the concept of Java Agent, compares it with AOP, and provides step‑by‑step implementations of both premain and agentmain modes, including Maven packaging, VM attachment, class transformation, redefinition, retransformation, and a Javassist example for method timing.
The article introduces Joylive Agent, a Java bytecode‑enhancement framework that implements a proxyless service‑mesh architecture for microservice governance, detailing its background, design principles, plugin system, bytecode manipulation techniques, traffic‑control strategies, multi‑active models, and deployment practices on Kubernetes.
This article explains the challenges of microservice communication and fault tolerance, introduces service mesh and its drawbacks, and presents a Java bytecode‑enhancement solution that combines SDK performance with sidecar‑less governance, detailing the Joylive Agent architecture, plugin system, request abstraction, governance strategies, and Kubernetes deployment practices.
This guide explains what Java Agents are, their core capabilities such as bytecode enhancement, performance monitoring, security checks, and debugging, and provides step‑by‑step instructions for implementing the premain method, creating a ClassFileTransformer, packaging the agent with Maven, and loading it both statically and dynamically.
Spring AOP cannot advise non‑bean, static, or internally‑called methods, limiting its use for the Diagnose framework, so the article proposes a Java Agent that transforms bytecode at startup, bypasses proxy constraints, and reliably intercepts private, static, and self‑invoked methods across separate class loaders.
This article explains how Alibaba Cloud engineers tackled the challenges of long startup times and high memory usage in Java serverless workloads by designing a static Java Agent instrumentation that works with GraalVM Native Image, preserving OpenTelemetry observability while dramatically improving performance.
Explore three Spring AOP implementation methods—dynamic proxy, Java Agent, and AspectJ Maven plugin—by setting up a sample Service, defining aspects, configuring aop.xml and JVM arguments, and comparing their flexibility, performance impact, and compile‑time weaving within a Spring Boot 2.7 environment.
AREX is an open‑source traffic recording and replay platform created by Ctrip that enables comprehensive testing—from performance and regression to rapid issue fixing—by capturing real traffic across complex micro‑service environments, addressing challenges such as async context, non‑idempotent calls, authentication, time‑sensitivity, and cache consistency, and offering easy CI/CD integration and large‑scale deployment.
The article introduces AREX, Ctrip’s open‑source traffic recording and replay platform, detailing its background, design decisions, technical challenges such as cross‑thread collection and non‑idempotent interfaces, deployment strategies, best‑practice integration with CI/CD pipelines, and the measurable benefits achieved across thousands of applications.
This article introduces the design and implementation of a remote hot‑deployment component (Mark42/Jarvis) built on Java Agent and an IDEA plugin, analyzes the challenges of dynamic compilation in Spring‑Boot fat‑jar environments, presents solution choices, and shares practical experiences and future directions.
This article details the design and implementation of Pylon APM, a Java‑agent based monitoring platform built on Pinpoint, covering background challenges, architectural decisions, trace‑model extensions, tail‑based sampling, Prometheus integration, automatic JStack collection, and the resulting product features for fast issue diagnosis.
The article details Meituan's large‑scale RASP (Runtime Application Self‑Protection) rollout, covering deployment challenges such as heterogeneous Java environments, performance impact of agent injection, upgrade difficulties, monitoring complexities, and the engineering solutions—including agentmain/premain hybrid loading, gray‑scale upgrades, hot‑update plugin architecture, and performance optimizations—validated with concrete metrics and benchmarks.
This article details the design and implementation of the Pylon APM monitoring platform for NetEase Cloud Music, covering background challenges, the choice of Pinpoint, extensions to trace models, tail‑based exception sampling, Prometheus integration, automated JStack collection, and the resulting APM product features.
This article explains how to replace invasive manual timing code with a lightweight Java Agent that leverages the java.lang.instrument API, ASM bytecode manipulation, and the Attach API to measure method execution time, perform dynamic class redefinition, and integrate with tools like Arthas for runtime tracing.
This article describes how the ZhiZhuan B2C backend team built a standardized logging, custom Apollo‑based log agent, Prometheus‑driven alerting service, and first‑responsible‑person mechanism to quickly locate and resolve service timeouts, exceptions, and other production issues, even when working off‑site.
This article describes Qunar's use of traffic recording and replay technology for fault isolation, performance optimization, and upgrade migration, detailing the evolution of their Java‑based agents, the end‑to‑end testing workflow, full‑link stress‑test integration, and the measurable business and performance outcomes.
This article explains the challenges of full‑chain load testing in microservice environments, compares component modification versus bytecode enhancement, selects ByteBuddy as the preferred bytecode library, describes the design and execution of a Java Agent (Sftc‑Agent), and discusses module architecture, class‑loader isolation, and future improvements.
This tutorial explains Java Agent technology, compares it with AOP, and provides step‑by‑step implementations of Premain and Agentmain modes, covering agent packaging, manifest configuration, instrumentation APIs, class transformation, redefinition, retransformation, and integration with Javassist for dynamic bytecode manipulation.
This article, based on a SACC 2022 talk by Huolala architect Cao Wei, explains the principles of bytecode‑enhancement, its practical implementation for large‑scale microservice monitoring, compares enhancement frameworks, shares best‑practice patterns, and explores broader applications such as service‑mesh sidecars.
This article explains why Java Agent injected via environment variables loads in every JVM inside a container, how that impacts JDK tools like java‑version and jstack, and presents a Dragonwell‑based solution using custom environment variables to limit agent loading only to business Java processes.
This article investigates intermittent Java Agent errors caused by Instrumentation.appendToSystemClassLoaderSearch in container environments, tracing the issue through JNI calls, glibc stat failures, locale‑dependent iconv conversion, and ultimately fixing it with pthread thread‑local storage and proxy wrappers.
This article explains how to use Dragonwell‑provided environment variables to inject Java Agents only into business Java processes in Kubernetes‑based microservices, avoiding unwanted agent loading for JDK tools while leveraging Alibaba Cloud MSE for seamless cloud‑native governance.
This guide explains how to integrate the open‑source Pyroscope platform with Rainbond to continuously profile microservices, detect CPU bottlenecks and memory leaks, and visualize performance data through its UI and various view modes.
Starting from mysterious Java Agent errors in Alibaba Cloud environments, this article traces the failure through the JVM’s Instrumentation.appendToSystemClassLoaderSearch call, examines glibc’s stat and iconv conversions, reveals thread‑local storage issues, and presents concrete fixes using pthread TLS and proxy wrappers.
vivo’s “Moonlight Treasure Box” platform records and replays production traffic using a customized Jvm‑Sandbox‑Repeater Java‑Agent, handling GC limits, thread‑pool tracing, data desensitization, deduplication, timestamp alignment, noise reduction and sub‑call matching, while providing plugins, visual call‑chain analysis and coverage metrics that have integrated 200 services, executed over 10 000 sessions, and boosted testing efficiency by more than 80 %.
The article details how Volcengine redistributed the Apache SkyWalking Java agent without proper licensing, presenting file comparisons, code similarities, and package structures as evidence, and describes the community’s reaction and the company’s subsequent apology and corrective actions.
This article explores using Byte Buddy to build Java agents, detailing the premain method, class loading mechanisms, handling dependency conflicts with Maven shade versus custom classloaders, and implementing a Dispatcher to bridge agent and application classloaders, providing practical code snippets and diagrams for each step.
This article walks through diagnosing a hidden Excel parsing exception using Arthas, identifies the root cause in header mapping logic, and then explains Java Agent fundamentals before providing a step‑by‑step demo that injects custom code into a running JVM.
The stability‑assurance squad built an online load‑testing framework that injects global TraceIds via a Java‑agent, records real‑traffic, routes test writes to shadow databases and caches, enforces automatic stop‑rules, and provides a UI platform, reducing cost, improving capacity insight, and enabling safe fault‑injection drills.
This article explains how to build a Java Agent that leverages bytecode instrumentation, class‑loader mechanisms, and AOP techniques to provide lightweight, configurable performance profiling and monitoring for Java services, covering requirements, technical foundations, implementation steps, and testing procedures.
This article explains what a Java ClassLoader is, details its core APIs such as defineClass, findClass, loadClass, and findResource, describes the parent‑delegation model, and demonstrates how custom ClassLoaders can be used for class isolation in Java agents, illustrated with real‑world log4j2 pitfalls and solutions.
Youzan’s full‑link tracing system combines a multi‑language SDK, Java Agent dynamic attachment, transparent upgrades, asynchronous context propagation, and a Spark‑based data pipeline that indexes traces in Elasticsearch and stores them in HBase, enabling real‑time diagnostics, log correlation, and future container‑level tracing expansion.
The article explains how JVM CPU profilers work by using Java or native agents—via JVMTI, JMX, or the AsyncGetCallTrace hack—to sample or instrument stack traces, generate flame graphs, and employ the HotSpot Attach API for live, zero‑restart agent loading and diagnostics.
This article walks through diagnosing intermittent OpenAPI latency by using Alibaba's open‑source TProfiler Java agent to collect method‑level timing without modifying code, covering setup, command‑line usage, log analysis, and practical performance‑improvement recommendations.
This article explains how to implement Java Instrumentation using a custom Java agent to achieve AOP‑style method timing without Spring, covering Instrument concepts, Maven manifest configuration, Agent entry points, JDK Attach API loading, class file transformers, annotation processing, and integration with QTrace for full‑stack tracing.
This article explains how to dynamically modify a Java project's properties at runtime without restarting the JVM by attaching a custom Java agent, configuring Maven dependencies, and using JConsole or Telnet for property updates.
This article explains Pinpoint’s architecture, its plugin system, key data structures like ServiceType and AnnotationKey, and demonstrates how to develop a custom bytecode‑injection plugin for Java applications to achieve low‑overhead distributed tracing.
The article introduces Qunit, an API automation testing framework built on JUnit, explains its zero‑intrusion Java Agent aspect for mocking third‑party services, and describes a distributed execution platform that creates isolated environments to run tests in parallel, dramatically reducing overall test execution time.
