This article explains the principles behind JVM monitoring tools by introducing JVMTI, the Java Instrumentation API, startup and runtime agents, the Attach mechanism, and demonstrates bytecode manipulation with ASM through detailed code examples and diagrams.
This article explains the basics of Java agents, demonstrates how to use premain and agentmain to modify bytecode at load time or during execution, and provides practical examples with ASM to monitor method execution time and capture method parameters and return values in running Java processes.
FlutterCodeX introduces a non‑intrusive, cross‑platform runtime code‑coverage SDK that instruments iOS, Android and Flutter apps—using meta‑class flags, Gradle‑injected static blocks, and the Dart AOP framework AspectD—to automatically record class‑initialization events, upload compressed data to Alibaba Cloud, and provide precise online coverage metrics for dead‑code removal and package‑size reduction in Xianyu.
This article explains how to instrument legacy Node.js back‑end projects with IstanbulJS, collect coverage data via memory sharing or file storage, and generate detailed reports, providing a practical solution for assessing system functionality without writing new unit tests.
This guide explains how to use Alibaba's Arthas tool to attach to a running Java process, inspect JVM metrics, execute hot code updates, and troubleshoot production issues without redeploying, covering download, common commands, and step‑by‑step hot‑swap procedures.
The article details Youzan Retail’s precise iOS testing platform, which instruments Objective‑C code via GCC/LLVM to generate .gcno/.gcda files, processes them with LCOV, and provides both full and git‑diff‑based incremental coverage visualizations across CI, data collection, parsing, and reporting layers to improve manual and automated test quality.
The article explains why production‑grade Java debugging must avoid stopping the JVM, then details Java‑Agent technology—including JVMTI, startup and runtime loading via the Attach mechanism—and shows how class redefinition and ASM‑based bytecode instrumentation can be combined in a TCP‑server tool to perform online fault isolation without pausing the application.
This article explains how Java objects store behavior and state, describes the JVM method area where method bytecode resides, and demonstrates runtime class modification using java.lang.instrument.Instrumentation, BTrace scripts, and the Arthas diagnostic tool to solve real‑world debugging problems.
The project implements a front‑end integration test coverage tool that instruments client code with a Babel plugin and server code with istanbul‑middleware, collects real‑time line/branch data via a Chrome extension and timed uploads, stores versioned results on a coverage server, and visualizes incremental coverage dashboards, providing an objective quality gate and achieving over 80 % incremental line coverage in production.
To meet strict quality goals for iOS projects, the article describes adopting intermediate‑file code‑coverage instrumentation, generating gcno/gcda files, using lcov for full and incremental analysis, and integrating the process into builds and CI to enforce coverage thresholds and guide test‑case design.
This article explains Java bytecode fundamentals, its class‑file layout, constant‑pool details, and then walks through practical bytecode‑enhancement techniques using ASM, Javassist, and the Instrument API to modify and reload classes at runtime for AOP, hot‑deployment and monitoring purposes.
This article explains gcov, the GCC‑bundled C/C++ code coverage tool, covering its basic concepts, the workflow for generating coverage data, and the instrumentation technique using basic blocks and arcs to record execution counts.
Java dynamic bytecode enhancement uses agents, the Instrumentation API, and the Attach API to modify class bytecode at load time without source changes, enabling non‑intrusive AOP features that power tools such as JRebel for hot deployment, Pinpoint for distributed tracing, Arthas for diagnostics, JVM‑SANDBOX for sandboxed interception, and JRARP for method call recording and playback.
Android activity startup latency stems from three phases—Pause, Launch, and Render—so optimizing only onCreate often leaves perceived delays; developers can measure each phase via system logs or AOP hooks (Instrumentation, Looper‑Printer, or ActivityThread handler) to pinpoint and reduce bottlenecks.
This article explains how Java's Load‑Time Weaving (LTW) enables static AOP via the java.lang.instrument package, details the core interfaces, demonstrates a complete code example with custom transformers and proxy classes, and shares practical tips for packaging the agent JAR.
MTHawkeye is Meitu’s iOS debugging and performance‑optimization toolkit that provides a three‑layer architecture—foundation, UI foundation, and plugin layers—to assist developers across development, testing, and production by offering memory leak detection, main‑thread profiling, CPU, network, graphics, storage monitoring, and integrated FLEX utilities.
The article explains how Java developers can dynamically trace and modify program behavior at runtime using the Instrumentation API, ASM bytecode manipulation, and the safe, annotation‑driven BTrace tool, illustrating techniques such as class redefinition, method interception, and examples like JSP recompilation and Arthas diagnostics.
This tutorial explains how to use Byte Buddy to build a JavaAgent for SkyWalking, debug and continuously integrate the agent, and develop custom SkyWalking plugins such as the kob scheduling framework, providing step‑by‑step code examples and configuration details for observability in Java backend services.
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 the JavaAgent feature introduced after JDK 1.5, its reliance on JVMTI and JPLISAgent, how to write premain classes and class file transformers, the role of MANIFEST.MF, and analyzes conflicts between Javassist‑based and ByteBuddy‑based agents when they modify the same class.
The Meituan Android team built an automated, non‑intrusive page‑speed plugin that injects SDK calls at compile time via a Gradle Transform, measures cold‑start, first render, network request and second render for Activities and Fragments—including ViewPager lazy loading—fetches real‑time config from a server and reports metrics to their monitoring platform.
This article explains the concept, measurement dimensions, and practical issues of code coverage, compares full and differential coverage, describes JaCoCo's on‑the‑fly and offline instrumentation techniques, and outlines how to resolve instrumentation conflicts in a Java service environment.
This article explains how to accurately measure iOS app cold and hot startup times, instrument CPU and memory usage at runtime using Xcode, mach APIs, and the Instruments tool, and provides practical steps and visual examples for performance optimization.
The article explains how the extremely low current and voltage consumption of IoT devices creates difficult measurement challenges for battery‑life estimation, discusses the limitations of conventional oscilloscopes, and outlines low‑noise instrumentation, signal‑conditioning, and multi‑function approaches engineers should adopt.
Android applications often suffer from high battery drain, slow launches, and UI lag, so this article explains three practical methods—using ADB commands, screenrecord video analysis, and code instrumentation—to measure and analyze app startup time, with detailed steps, interpretation of timing metrics, and visual examples.
This article explains how to measure the execution time of Java methods by first using an intrusive approach that embeds timing code directly in each method, then introduces a cleaner solution based on Java's dynamic proxy mechanism to separate performance monitoring from business logic.
This article demonstrates how to employ Java's java.lang.instrument API together with Javassist to create a Java agent that instruments bytecode at runtime, enabling performance monitoring without modifying the original application code.
This article explains how to perform code‑level performance measurement in Java services, compares the traditional intrusive approach with a cleaner solution using JDK dynamic proxies, and demonstrates how to decouple timing logic from business code.
