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 explores the challenges of traditional Android APM integration and presents a comprehensive, non‑intrusive bytecode instrumentation approach—using Gradle plugins, AGP APIs, and ASM—to automatically collect user behavior, network, performance, crash, and WebView data without modifying application source code.
This article provides a comprehensive technical guide covering Java bytecode structure, the seven-stage class lifecycle, JIT compilation, memory layout, garbage‑collection algorithms, execution engine details, and both static and dynamic bytecode enhancement techniques such as ASM, Javassist, and Java agents.
This article explains the concept of Android Hook, demonstrates how to intercept View.OnClickListener using Java reflection, shows step‑by‑step code for hooking startActivity via ActivityThread instrumentation, and introduces the Xposed framework’s mechanism for system‑wide method interception, providing practical examples and key implementation 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.
The article explains the rapid evolution of the AI application ecosystem, outlines the challenges of end‑to‑end observability for large‑language‑model services, and details how the open‑source LoongSuite suite—through non‑intrusive instrumentation for Python and Go agents and tight integration with the Dify platform—provides comprehensive, cloud‑native monitoring, tracing, and metric collection across the entire AI stack.
This article explains OpenTelemetry’s purpose, three‑layer architecture (instrumentation, collector, backend), practical Go instrumentation code, and how the collector processes and exports telemetry to both open‑source and SaaS backends, helping developers avoid vendor lock‑in and achieve unified observability.
This article details ZhiZhuan Group's end‑to‑end code‑coverage system for Android and iOS apps, covering its background, design, incremental instrumentation, CI/CD integration, optimization steps, visual reporting, and real‑world impact, offering practical insights for mobile development teams seeking reliable test coverage.
This article explains the concept of Hook in Android, demonstrates how to intercept View OnClickListener and startActivity using Java reflection and instrumentation, and introduces the Xposed framework for system‑wide method hooking, providing step‑by‑step code examples and practical deployment tips.
This article explains how to replace invasive manual timing code with Java Instrumentation, demonstrating both premain and agentmain approaches, building and attaching agents, using ASM and Bytekit for bytecode enhancement, and leveraging Arthas for runtime tracing and debugging.
This article explains how Spring Cloud automatically wraps managed thread pool beans with trace-enabled proxies to preserve distributed tracing information, details the ExecutorBeanPostProcessor implementation, shows the relevant configuration and instrumentation code, and notes that manually created executors must be wrapped manually.
This article explains the fundamentals of ASM’s tree API for Java bytecode manipulation, illustrates the structure of class files, fields, methods, and signatures, and provides a practical example of inserting code to rename anonymous Thread instances during the Transform phase.
UprobeStats, introduced in Android 15, uses the Linux kernel eBPF uprobe mechanism to dynamically insert probes into user‑space methods, capture timestamps and arguments, load BPF programs, and forward the data to StatsD via configurable protobufs, enabling flexible, source‑free instrumentation with minimal overhead.
This article compares the traditional Xposed‑based dynamic privacy checker with a new Gradle‑plugin instrumentation approach, explains the design and implementation of the Transform API‑driven solution, shows performance metrics, provides usage instructions, and outlines automated testing and future improvements for Android apps.
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 how Byteman's IMPORT declaration lets developers explicitly reference classes across modules, handling classloader scopes, providing code examples, key points, and plugin support for various Java module systems.
Amid the surge of cloud‑native architectures, Alibaba Cloud showcases its open‑source, compile‑time Go instrumentation that delivers non‑intrusive monitoring, richer data, and cross‑vendor standards via OpenTelemetry, while highlighting extensive community contributions and collaborations that position it as a leading force in modern observability.
This article analyzes the shortcomings of a custom Istanbul-based code coverage pipeline for a Vue frontend, explains why instrumented line numbers were inaccurate, and presents a revised solution using NYC to generate reliable incremental coverage reports with detailed implementation steps and configuration examples.
This article explains Byteman's injection point specifiers—AT LINE, AT READ, AFTER READ, AT WRITE, AFTER WRITE, AT INVOKE, AFTER INVOKE, AT NEW, AFTER NEW, AT SYNCHRONIZE, AFTER SYNCHRONIZE, AT THROW, and AT EXCEPTION EXIT—detailing their syntax, matching rules, counting options, and practical usage in Java bytecode instrumentation.
Byteman is a powerful Java bytecode manipulation tool that lets developers inject custom code at runtime without recompiling, using an event‑condition‑action rule language to trace, modify execution flow, coordinate threads, and collect statistics, with detailed examples of rule syntax, binding, and built‑in actions.
This article compares three Go observability solutions—SDK instrumentation, eBPF‑based monitoring, and compile‑time code injection—explaining their mechanisms, open‑source implementations, trade‑offs, and why Alibaba Cloud's Instgo compile‑time approach offers a low‑overhead, non‑intrusive APM alternative.
This article explains how Java agents work, compares premain and attach agents, shows how to implement entry points, use Instrumentation and Javassist to transform bytecode, provides complete code samples, packaging instructions, and demonstrates the runtime output with diagrams.
This guide explains how Alibaba's open‑source Golang Agent enables full observability for Go applications without modifying source code, covering download, compilation, endpoint configuration, and examples of trace, metric, and log correlation using Docker and OpenTelemetry.
This article explains how to replace invasive manual timing code with a lightweight Java Agent that uses the java.lang.instrument API, ASM bytecode manipulation, and Attach/Arthas tools to automatically measure method execution time and perform dynamic class transformation at runtime.
This article demonstrates how to replace invasive manual timing code with Java Agent‑based instrumentation, covering the use of java.lang.instrument, premain and agentmain methods, dynamic class retransformation via the Attach API, and practical examples including method‑level timing, runtime class modification, and integration with Arthas for tracing.
This article introduces a compile‑time, zero‑intrusion auto‑instrumentation technique for Go applications that enables seamless monitoring, service governance, security checks, and traffic protection through modular JSON‑driven code injection, with practical examples covering HTTP headers, sorting algorithms, SQL injection prevention, and gRPC traffic control.
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 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.
Airbnb’s Android Page Performance Score (PPS) framework instruments fragments to collect user‑centric metrics such as TTFL, TTIL, MTH, ALT and RCLT, using a standardized logging config, LoadableView interface, and visibility algorithms, enabling detailed performance analysis and automated alerts for mobile teams.
Airbnb’s iOS Page Performance Score implementation introduces a PPSStateMachine that ties a UIViewController’s lifecycle to metric collection—tracking first layout, initial load, scroll thread hangs, additional and rich content load times—using nanosecond timestamps, state‑machine protocols, and view‑responder discovery to emit standardized performance logs.
The new OpenTelemetry Java instrumentation adds client and server request‑size metrics to gRPC by injecting a tracing interceptor via Byte‑Buddy bytecode enhancement, extracting payload sizes from protobuf messages, recording them with custom attributes and histograms, and applying analogous handler‑based logic for Go.
This article explains the concept of JavaAgent, its underlying mechanism using the JVM instrumentation API, and provides a step‑by‑step guide with code samples to build a JavaAgent that measures method execution time in a Spring application.
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.
Starting in April, several Android projects began crashing on Huawei HarmonyOS devices with TooManyRequestsException errors; this article details the investigation, source code analysis of registerDefaultNetworkCallback across Android versions, and proposes instrumentation and code‑level solutions to prevent excessive network callback registrations.
This article examines critical gaps in modern code review processes, highlighting the lack of performance testing, common feedback pitfalls, and practical strategies—including instrumentation tools like Digma—to ensure code quality, system reliability, and efficient collaboration in increasingly complex software pipelines.
This guide explains how the Go Agent injects observability code at compile time to provide automatic tracing and metrics for Golang microservices running on Kubernetes, covering its architecture, supported SDKs, compatibility, and step‑by‑step deployment instructions including component installation, binary compilation, and YAML configuration.
Canyon extends the IstanbulJS ecosystem with a Babel‑based instrumentation plugin, real‑time coverage aggregation, and cloud‑native reporting to enable large‑scale end‑to‑end UI automation coverage for modern JavaScript front‑end applications, including SPA, MPA, and React Native environments.
The article walks through building a custom OpenTelemetry Java‑agent extension for Pulsar client metrics—migrating from SkyWalking, setting up a Gradle project, using ByteBuddy to instrument methods with advice, registering gauge metrics, packaging the jar, handling common class‑loader pitfalls, and configuring deployment via the OpenTelemetry operator.
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 explains how Java achieves "write once, run anywhere" through platform‑independent bytecode, describes the .class file structure, introduces tools for viewing bytecode, and provides detailed guidance on using the ASM library’s Core and Tree APIs for bytecode enhancement, including practical code demos and application scenarios.
By inserting a custom AopTransformer into Flutter’s front‑end compilation pipeline before optimization, the proposed Dart AOP solution automatically injects logging hooks that capture full‑stack user interaction paths and business state without modifying business code, delivering zero‑impact, maintainable instrumentation for improved debugging and app stability.
This article explains how Android’s battery statistics work, demonstrates a low‑overhead bytecode instrumentation technique to monitor power‑hungry APIs such as WakeLocks, GPS and sensors, and shows practical examples of detecting and fixing real‑world battery‑draining bugs in production apps.
This article provides a comprehensive guide to front‑end monitoring, covering performance metrics, exception alerts, daily inspections, instrumentation methods, data collection, log storage, and practical code examples for building a robust monitoring system that improves stability, user experience, and business insight.
This article presents a visual catalog of twenty key industrial sensors, ranging from flaw detectors and oxygen sensors to ultrasonic density meters, each illustrated with an image and a brief English description of its measurement principle.
The article introduces a lightweight bytecode‑enhancement framework that weaves interceptors directly into Java methods to record execution times and call hierarchies, avoiding proxy overhead, supporting synchronous, asynchronous and lambda scenarios, and enabling precise performance monitoring and tracing across micro‑service architectures.
This article explains how Java objects store attributes and shared behavior, describes the JVM method area where method bytecode resides, and demonstrates runtime bytecode manipulation using java.lang.instrument.Instrumentation, BTrace scripts, and the Arthas diagnostic tool to solve real‑world debugging problems.
This article details the investigation of a SkyWalking thread‑pool plugin enhancement failure caused by multiple AgentClassLoader instances, explains the debugging steps, class‑loading behavior, and provides two practical solutions to ensure proper bytecode instrumentation for ThreadPoolExecutor in Java applications.
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 explains the root cause of the thread‑pool plugin enhancement failure in SkyWalking—duplicate AgentClassLoader instances—detailing the investigation steps, code changes, and two practical solutions to ensure reliable instrumentation of ThreadPoolExecutor.
This article introduces Bistoury, a one‑stop Java application diagnostic solution that improves upon Arthas by adding a web UI, multi‑machine support, integrated agent‑proxy architecture, custom classloaders, online debugging, per‑thread CPU monitoring, and heap object statistics.
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.
Android method tracing, a Google‑provided Java‑level profiling tool, captures function‑level execution times via sampling or explicit enter/exit hooks, outlines its startup flow and collection categories, and describes recent Android advances such as JIT‑generated hooks and instrument‑based replacement of trace‑odex support.
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 introduces Java Agent technology, explains the differences between premain and agentmain modes, demonstrates how to build, package, and attach agents using Maven and the Attach API, and shows practical bytecode manipulation techniques with Instrumentation and Javassist, complete with code examples.
This article examines why a single Thread.currentThread().getStackTrace() call is insufficient for modern Android performance debugging, compares instrumentation and native stack‑capture approaches, and provides detailed step‑by‑step implementations, code snippets, and optimization tips for reliable stack tracing.
JVM‑Sandbox provides a non‑intrusive, runtime AOP solution for Java backend applications, enabling developers to instrument code outside the Spring container, record traffic, hot‑fix vulnerabilities, simulate failures, and monitor Spring bean initialization, all through JVMTI, Instrumentation, and event‑driven modules.
This article explains ByteDance's large‑scale adoption of profile‑guided optimization (PGO), covering its principles, instrumentation and sampling methods, the automated platform built for data collection and compilation, and the resulting performance gains across dozens of critical services.
This article explains a comprehensive approach to detecting and analyzing Android app power consumption by combining official power profiling, custom metrics, and bytecode instrumentation to capture API usage, caller information, and timing for modules such as Bluetooth, CPU, location, sensors, wakelocks, and alarms.
This article explains how Alipay measures and improves Android cold‑start performance through video‑frame analysis, ActivityTaskManager, custom instrumentation, home‑page snapshot techniques, temperature control, patch‑APK data collection, AOP‑based diagnostics, and an integrated APM platform.
This article introduces JVM‑Sandbox, explains its non‑intrusive AOP capabilities, and provides a step‑by‑step tutorial on installing the sandbox, loading custom modules, performing code enhancement via instrumentation, and testing exception injection in a Java service.
To cut the NetEase Cloud Music iOS app’s sluggish launch, the team trimmed dynamic libraries, replaced costly +load registrations with static modules, swapped SBJson for native parsing, reordered binaries, lazy‑loaded heavy services and ads, and streamlined UI initialization, delivering over 30 % faster cold‑starts and urging ongoing performance monitoring.
This article details Baidu's comprehensive approach to improving Android app launch performance by evaluating existing tracing tools, selecting Perfetto, developing a Gradle-based automatic instrumentation plugin, handling trace collection and analysis with Trace Processor, and implementing automated detection of regressions, lock contention, and method-level CPU and wall‑time degradations.
This article explains how to build a high‑precision Android startup performance pipeline by selecting the right tracing tool, extending Perfetto with custom Gradle instrumentation, handling edge‑case trace mismatches, and using Trace Processor’s Python API for automated wall‑time and CPU‑time regression detection.
Alipay’s client engineering team details a comprehensive approach to monitoring, measuring, and improving time‑consuming user experiences—especially cold‑start—by employing video frame analysis, ActivityTaskManager, extensive instrumentation, home‑page snapshot techniques, temperature control, patch‑APK injection, AOP‑based diagnostics, and the Spider SDK within a robust APM platform.
This article explores how to eliminate repetitive monitoring code in Java services by building a compile‑time instrumentation component that leverages JSR‑269 annotation processing and AST manipulation, detailing the component design, technical selection, compiler internals, implementation steps, and lessons learned.
This article explains how a Java compiler‑time AST injection component replaces manual monitoring instrumentation with a simple @UMP annotation, detailing the technology selection, implementation using JSR‑269 annotation processors, and the trade‑offs of compile‑time versus runtime weaving.
The article introduces AREX, a Java instrumentation framework that captures real production traffic to create high‑coverage, low‑cost automated regression tests for complex backend systems, detailing its architecture, trace propagation techniques, and open‑source implementation.
This article explores the design and implementation of MemoryLimitedLBQ and MemorySafeLBQ, two custom LinkedBlockingQueue variants that limit memory usage to avoid Out‑Of‑Memory errors in Java thread pools, comparing their mechanisms, instrumentation dependencies, and practical usage in open‑source projects.
By using Chrome DevTools and Istanbul/NYC to measure JavaScript coverage, developers can detect dead and low‑usage code, then convert such modules into dynamic imports via build plugins, enabling tree‑shaking and code‑splitting that reduces bundle size and speeds up first‑screen rendering.
This article details Meituan's internal Sonic IDEA plugin, explaining hot‑deployment concepts, why they matter, the technical challenges, and Sonic's architecture—including agents, instrumentation, class reloading, Spring Bean/XML/MyBatis reloads, and real‑world deployment experience—showing how code changes can become effective in seconds instead of minutes.
This article explains how Java objects store behavior in the method area, introduces the java.lang.instrument.Instrumentation API for redefining classes at runtime, and demonstrates practical dynamic tracing techniques using BTrace and Arthas, complete with code examples and architectural insights.
The article details Meituan's internal Sonic IDEA plugin for remote and local hot deployment, explaining why hot deployment is needed, its architecture, instrumentation techniques, DCEVM integration, file‑watching, class reloading, and support for Spring Bean, Spring XML and MyBatis, along with adoption statistics and performance benefits.
This article introduces DexInjector, a tool for directly instrumenting Android APK dex files to insert logging, performance monitoring, and third‑party hooks without recompiling, explains the underlying technical research, design choices, implementation details, handling of method limits, string jumbo, obfuscation, class conflicts, and provides code examples and workflow diagrams.
This article explains how Java object behavior can be altered at runtime using the JVM method area, java.lang.instrument.Instrumentation, bytecode frameworks like ASM, the BTrace tracing tool, and the Arthas diagnostic utility, providing practical code examples and usage guidelines.
The Marko integrated code‑coverage platform, presented by vivo’s front‑end team, offers a zero‑intrusion, one‑click solution that collects and merges multi‑language coverage data during integration testing, visualizes incremental reports and diffs through a three‑layer architecture, supports Git and OAuth, provides real‑time dashboards and alerts, and is slated for broader language support and open‑source release.
OpenTelemetry unifies tracing, metrics, and logs by merging OpenTracing and OpenCensus into a cross‑language specification, collector, language SDKs, and instrumentation libraries, offering vendor‑agnostic, low‑maintenance telemetry collection that separates data gathering from business logic while requiring external back‑ends for storage and analysis.
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 practical iOS startup optimization, covering monitoring strategies, non‑intrusive instrumentation, development‑stage testing, essential tools like Time Profiler and System Trace, and a comprehensive set of best‑practice tactics to shrink launch time and maintain performance.
This tutorial explains how to build a custom Gradle Transform plugin, integrate ASM bytecode manipulation, and instrument Android applications to detect and report illegal privacy API calls, covering project setup, plugin implementation, ASM basics, and practical verification steps.
This tutorial demonstrates how to create a simple Go application, expose the default Prometheus metrics endpoint, add custom gauge metrics, use a custom registry, and work with counters, histograms, summaries, and label vectors to fully instrument Go services for monitoring.
This article introduces Arthas, a Java online diagnostic tool, explains its instrumentation‑based runtime principle, guides installation on various platforms, and provides a comprehensive command reference—including basic, system, class, and enhancement commands—for effective debugging, monitoring, and performance analysis of Java applications.
This article explains what code coverage is, why it matters, the different coverage metrics, how coverage measurement works, and reviews several mainstream tools across various programming languages.
The article reveals that while DevOps has exploded with trends like Hybrid Deployments, DataOps, and GitOps, the overlooked but critical shift toward non‑invasive production debugging—providing code‑level observability without disrupting services—will become essential for modern DevOps teams.
The article explores the rising DevOps trend of non‑invasive production debugging, explaining its advantages over traditional log‑based methods, detailing instrumentation techniques, showing code examples, and highlighting its impact on key DevOps metrics and industry adoption.
This article explains how Java object behavior is stored in the JVM method area, how to use java.lang.instrument.Instrumentation, direct bytecode manipulation, BTrace, and Arthas to modify methods at runtime without changing object state, and provides practical code examples and tool architectures.
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.
This article explains how Java object behavior is stored in the JVM method area, explores dynamic bytecode manipulation using java.lang.instrument.Instrumentation, demonstrates practical tracing with BTrace, and introduces Arthas as a user‑friendly diagnostic tool for runtime debugging and monitoring.
This article explores how Java developers can use the ASM framework, the Instrument API, and JVM TI to dynamically generate and transform bytecode at runtime, enabling powerful debugging features like Evaluate and custom agents for class redefinition.
This article details the design and implementation of a Flutter code coverage tool that instruments Dart's intermediate Dill files using AspectD, covering its background, instrumentation principles, code snippets, data collection, analysis, reporting, and observed improvements in testing efficiency.
This article explores how Java's method area stores object behavior, how the java.lang.instrument.Instrumentation API enables runtime class redefinition, and how tools like ASM, BTrace, and Arthas empower developers to inject bytecode, trace methods, and debug production systems without source changes.
This article explains how Java objects store behavior and attributes, describes the JVM method area where method bytecode resides, and demonstrates practical dynamic tracing techniques using java.lang.instrument.Instrumentation, BTrace scripts, and the Arthas diagnostic tool.
This article describes the purpose, design choices, instrumentation technique, data collection, reporting, merging strategies, platform features, and future plans of a custom code‑coverage system built for the Android and iOS versions of the Zhuanzhuan app, highlighting challenges such as accurate instrumentation, performance impact, and multi‑tag data aggregation.
The article explains how to enhance Java bytecode using a javaagent, covering bytecode fundamentals, agent loading during JVM startup, implementation steps, transformation via ClassFileTransformer, and popular tools such as ASM, Javassist, and ByteBuddy for non‑intrusive runtime instrumentation and monitoring.
The article explains how to use JaCoCo to instrument Android SDK classes—detailing probe insertion strategies for methods, branches, and code blocks, offline and Ant/Gradle integration, building instrumented packages, collecting execution data, and generating HTML coverage reports without modifying source code.
The guide walks developers through Android testing basics by explaining JUnit unit tests, instrumented tests, and Espresso UI tests, showing where local and device tests reside, demonstrating how to generate a Calculator unit test and an Espresso test for a simple activity, and how to run them in Android Studio.
The article explains how to instrument code for coverage using LLVM’s modular compiler infrastructure—adding compile‑time probes that generate .gcno files, runtime counters that produce .gcda files, and then parsing these with GCOV, while detailing LLVM IR, basic blocks, flow graphs, and extensions for custom plugins.
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.
