BestHub
Sign in
Tagged articles

instrumentation

129 articles · Page 1 of 2
Architecture Development Notes
Architecture Development Notes
Sep 8, 2026 · Artificial Intelligence

OpenTelemetry GenAI Semantic Conventions: Modeling Agent Runs as Span Trees

The article explains how OpenTelemetry GenAI semantic conventions address the gap in agent observability by defining a standardized span tree structure (invoke_agent, execute_tool, chat, etc.) and three critical fields (gen_ai.agent.name, gen_ai.conversation.id, gen_ai.operation.name) to capture tool calls, retries, and child-agent handoffs that auto-instrumentation misses.

GenAILLM agentsOpenTelemetry
0 likes · 10 min read
OpenTelemetry GenAI Semantic Conventions: Modeling Agent Runs as Span Trees
Programmer1970
Programmer1970
Jul 23, 2026 · Fundamentals

6 Real Scenarios That Break Java’s ClassLoader Parent‑Delegation Model

The article examines six practical situations—SPI, Tomcat WebAppClassLoader, OSGi bundles, JDBC driver loading, custom ClassLoaders, and Java agents—where Java’s default parent‑delegation class‑loading mechanism is intentionally bypassed, explaining the motivations, implementations, and associated risks of each approach.

ClassLoaderJavaOSGi
0 likes · 13 min read
6 Real Scenarios That Break Java’s ClassLoader Parent‑Delegation Model
AntTech
AntTech
May 12, 2026 · Operations

Solving GenAI Observability Standardization with LoongSuite’s Unified Data Language

The article details how Alibaba and Ant Group’s LoongSuite GenAI observability semantic conventions use a unified data language to standardize GenAI telemetry, introduce entry/step spans, skill semantics, and token‑level tracing, and provide a reusable GenAI Utils library for scalable deployment across agents and inference engines.

GenAILoongSuiteOpenTelemetry
0 likes · 22 min read
Solving GenAI Observability Standardization with LoongSuite’s Unified Data Language
Architect's Guide
Architect's Guide
Nov 1, 2025 · Backend Development

How to Use Java Agents for Non‑Intrusive Method Timing and Tracing

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.

ArthasBytekitJava
0 likes · 24 min read
How to Use Java Agents for Non‑Intrusive Method Timing and Tracing
Alibaba Cloud Observability
Alibaba Cloud Observability
Oct 27, 2025 · Mobile Development

How to Build a Zero‑Intrusion Android Data Collection SDK with Bytecode Instrumentation

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.

APMAndroidGradle
0 likes · 21 min read
How to Build a Zero‑Intrusion Android Data Collection SDK with Bytecode Instrumentation
Tech Freedom Circle
Tech Freedom Circle
Oct 11, 2025 · Fundamentals

JIT, Class Lifecycle Stages, and Bytecode Enhancement – Core Concepts for Java Interviews

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.

ASMClass LoadingGarbage Collection
0 likes · 74 min read
JIT, Class Lifecycle Stages, and Bytecode Enhancement – Core Concepts for Java Interviews
Architect's Guide
Architect's Guide
Oct 10, 2025 · Mobile Development

Master Android Hooking: From View OnClickListener to Xposed Framework

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.

AndroidJava ReflectionXposed
0 likes · 12 min read
Master Android Hooking: From View OnClickListener to Xposed Framework
Architect's Guide
Architect's Guide
Sep 15, 2025 · Backend Development

How to Use Java Agents and Instrumentation for Non‑Intrusive Performance Monitoring

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.

ArthasAttach APIJava
0 likes · 19 min read
How to Use Java Agents and Instrumentation for Non‑Intrusive Performance Monitoring
Code Ape Tech Column
Code Ape Tech Column
Sep 11, 2025 · Backend Development

Instantly Debug SpringBoot Apps in Production Without Restart

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.

ByteBuddyJava AgentOnline Debugging
0 likes · 18 min read
Instantly Debug SpringBoot Apps in Production Without Restart
Alibaba Cloud Native
Alibaba Cloud Native
Aug 27, 2025 · Artificial Intelligence

How LoongSuite Enables Full‑Stack Observability for LLM Applications

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.

AIDifyLLM
0 likes · 19 min read
How LoongSuite Enables Full‑Stack Observability for LLM Applications
Ops Development & AI Practice
Ops Development & AI Practice
Jul 12, 2025 · Cloud Native

Mastering Observability: A Deep Dive into OpenTelemetry’s Architecture

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.

Collectorcloud-nativedistributed tracing
0 likes · 9 min read
Mastering Observability: A Deep Dive into OpenTelemetry’s Architecture
大转转FE
大转转FE
Jun 20, 2025 · Mobile Development

Boosting Mobile App Quality: ZhiZhuan’s Scalable Code Coverage Solution

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.

AndroidCI/CDMobile Development
0 likes · 18 min read
Boosting Mobile App Quality: ZhiZhuan’s Scalable Code Coverage Solution
Architect's Guide
Architect's Guide
Jun 19, 2025 · Mobile Development

Master Android Hooking: From API Hook to Xposed Framework

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.

API HookAndroidXposed
0 likes · 13 min read
Master Android Hooking: From API Hook to Xposed Framework
Cognitive Technology Team
Cognitive Technology Team
Apr 16, 2025 · Backend Development

Automatic Trace-Wrapped ThreadPool Instances in Spring Cloud

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.

JavaSpring CloudThreadPool
0 likes · 7 min read
Automatic Trace-Wrapped ThreadPool Instances in Spring Cloud
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Feb 21, 2025 · Mobile Development

UprobeStats: Dynamic User‑Space Instrumentation on Android via eBPF uprobe

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.

AndroidBPFStatsD
0 likes · 16 min read
UprobeStats: Dynamic User‑Space Instrumentation on Android via eBPF uprobe
Sohu Tech Products
Sohu Tech Products
Feb 19, 2025 · Information Security

Replacing Xposed with a Gradle Plugin for Automated Android Privacy Checks

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.

ASMAndroidDynamic Analysis
0 likes · 12 min read
Replacing Xposed with a Gradle Plugin for Automated Android Privacy Checks
FunTester
FunTester
Feb 16, 2025 · Operations

How to Run Byteman Scripts, Dynamically Submit Rules, and Perform Offline Checks

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.

BytemanDevOpsJava Agent
0 likes · 8 min read
How to Run Byteman Scripts, Dynamically Submit Rules, and Perform Offline Checks
Alibaba Cloud Observability
Alibaba Cloud Observability
Feb 11, 2025 · Operations

Alibaba Cloud’s Compile‑Time Go Instrumentation: A New Era for Cloud‑Native Observability

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.

Alibaba CloudGoOpenTelemetry
0 likes · 6 min read
Alibaba Cloud’s Compile‑Time Go Instrumentation: A New Era for Cloud‑Native Observability
大转转FE
大转转FE
Feb 10, 2025 · Fundamentals

Why Frontend Coverage Reports Were Wrong and How NYC Fixed Them

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.

Frontend TestingIstanbulcode coverage
0 likes · 19 min read
Why Frontend Coverage Reports Were Wrong and How NYC Fixed Them
FunTester
FunTester
Feb 7, 2025 · Backend Development

Mastering Byteman: How AT LINE, AT READ, and Other Specifiers Control Java Bytecode Injection

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.

BytemanJavaSpecifiers
0 likes · 12 min read
Mastering Byteman: How AT LINE, AT READ, and Other Specifiers Control Java Bytecode Injection
FunTester
FunTester
Jan 16, 2025 · Backend Development

Mastering Byteman: Injecting Bytecode for Advanced Java Testing

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.

JavaRule Enginebytecode
0 likes · 12 min read
Mastering Byteman: Injecting Bytecode for Advanced Java Testing
Alibaba Cloud Observability
Alibaba Cloud Observability
Dec 24, 2024 · Operations

How to Achieve Full Observability for Go Apps Without Intrusive Agents

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.

GoOpenTelemetrycloud-native
0 likes · 11 min read
How to Achieve Full Observability for Go Apps Without Intrusive Agents
Architect
Architect
Dec 2, 2024 · Backend Development

Mastering Java Agents: Premain vs Attach for Bytecode Manipulation

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.

AgentAttachJava
0 likes · 17 min read
Mastering Java Agents: Premain vs Attach for Bytecode Manipulation
Architect
Architect
Nov 19, 2024 · Backend Development

Java Agent and Instrumentation: Non‑Intrusive Method Timing, Attach API, and Arthas Trace

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.

JavaJavaAgentbytecode
0 likes · 20 min read
Java Agent and Instrumentation: Non‑Intrusive Method Timing, Attach API, and Arthas Trace
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 19, 2024 · Operations

Zero‑Intrusion Go Instrumentation: Auto‑Inject Monitoring & Governance

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.

GoService Governancecode injection
0 likes · 17 min read
Zero‑Intrusion Go Instrumentation: Auto‑Inject Monitoring & Governance
Code Ape Tech Column
Code Ape Tech Column
Oct 14, 2024 · Backend Development

Understanding Java Agent: Premain and Agentmain Modes with Instrumentation

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.

AgentmainBytecode ManipulationJava Agent
0 likes · 17 min read
Understanding Java Agent: Premain and Agentmain Modes with Instrumentation
Airbnb Technology Team
Airbnb Technology Team
Sep 19, 2024 · Mobile Development

How Airbnb Instruments Android Apps to Capture User‑Centric Performance Metrics

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.

AndroidMobile DevelopmentPerformance Monitoring
0 likes · 10 min read
How Airbnb Instruments Android Apps to Capture User‑Centric Performance Metrics
Airbnb Technology Team
Airbnb Technology Team
Sep 9, 2024 · Mobile Development

Implementing Page Performance Score on iOS: PPSStateMachine, Metrics, and Instrumentation

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.

Mobile DevelopmentPage Performance ScoreSwift
0 likes · 9 min read
Implementing Page Performance Score on iOS: PPSStateMachine, Metrics, and Instrumentation
Sohu Tech Products
Sohu Tech Products
Sep 5, 2024 · Backend Development

Instrumentation of gRPC in OpenTelemetry: Adding Request Size Metrics via Byte‑Buddy

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.

ByteBuddyJavaOpenTelemetry
0 likes · 12 min read
Instrumentation of gRPC in OpenTelemetry: Adding Request Size Metrics via Byte‑Buddy
FunTester
FunTester
Aug 14, 2024 · Backend Development

Mastering Java Agents: Build, Package, and Deploy Runtime Instrumentation

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.

JavaJava AgentMaven
0 likes · 10 min read
Mastering Java Agents: Build, Package, and Deploy Runtime Instrumentation
Huolala Tech
Huolala Tech
Aug 5, 2024 · Mobile Development

Why Android Apps Crash on Huawei Devices: TooManyRequestsException Explained and Fixes

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.

AndroidHuaweiNetworkCallback
0 likes · 16 min read
Why Android Apps Crash on Huawei Devices: TooManyRequestsException Explained and Fixes
21CTO
21CTO
Jul 31, 2024 · Fundamentals

Why Most Code Reviews Miss Performance Issues—and How to Fix Them

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.

CI/CDCode Reviewinstrumentation
0 likes · 7 min read
Why Most Code Reviews Miss Performance Issues—and How to Fix Them
Alibaba Cloud Native
Alibaba Cloud Native
Jul 2, 2024 · Cloud Native

How Go Agent Enables Zero‑Intrusion Monitoring for Golang Microservices on Kubernetes

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.

ARMSGoKubernetes
0 likes · 17 min read
How Go Agent Enables Zero‑Intrusion Monitoring for Golang Microservices on Kubernetes
Ctrip Technology
Ctrip Technology
Jun 14, 2024 · Frontend Development

Canyon: A JavaScript End‑to‑End Test Coverage Solution for Frontend Projects

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.

CI/CDCanyonJavaScript
0 likes · 19 min read
Canyon: A JavaScript End‑to‑End Test Coverage Solution for Frontend Projects
Sohu Tech Products
Sohu Tech Products
Apr 17, 2024 · Operations

Developing an OpenTelemetry Extension for Pulsar Java Client Metrics

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.

ExtensionJavaJavaAgent
0 likes · 14 min read
Developing an OpenTelemetry Extension for Pulsar Java Client Metrics
Meituan Technology Team
Meituan Technology Team
Jan 18, 2024 · Information Security

Meituan Java RASP: Architecture, Challenges, and Performance Optimizations

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.

Gray DeploymentJava AgentPerformance Optimization
0 likes · 31 min read
Meituan Java RASP: Architecture, Challenges, and Performance Optimizations
政采云技术
政采云技术
Dec 26, 2023 · Backend Development

Understanding Java Bytecode and Using ASM for Bytecode Manipulation

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.

ASMBytecode ManipulationJVM
0 likes · 16 min read
Understanding Java Bytecode and Using ASM for Bytecode Manipulation
DeWu Technology
DeWu Technology
Dec 13, 2023 · Mobile Development

Dart AOP‑Based Full Instrumentation for Flutter Applications

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.

AOPDartFlutter
0 likes · 18 min read
Dart AOP‑Based Full Instrumentation for Flutter Applications
Huolala Tech
Huolala Tech
Dec 12, 2023 · Mobile Development

How to Detect and Optimize Android App Battery Drain with Bytecode Hooking

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.

AndroidPerformance Monitoringbattery optimization
0 likes · 26 min read
How to Detect and Optimize Android App Battery Drain with Bytecode Hooking
DeWu Technology
DeWu Technology
Nov 8, 2023 · Frontend Development

Mastering Front‑End Monitoring: From Performance to Error Alerts

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.

Error TrackingJavaScriptPerformance
0 likes · 20 min read
Mastering Front‑End Monitoring: From Performance to Error Alerts
DeWu Technology
DeWu Technology
Sep 11, 2023 · Backend Development

Bytecode Enhancement for Method Call Interception and Performance Monitoring

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.

AOPJavaMethodInterception
0 likes · 24 min read
Bytecode Enhancement for Method Call Interception and Performance Monitoring
Architect's Tech Stack
Architect's Tech Stack
Aug 12, 2023 · Backend Development

Understanding Java Object Behavior, Method Area, and Dynamic Tracing with Instrumentation, BTrace, and Arthas

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.

ArthasBTraceJava
0 likes · 15 min read
Understanding Java Object Behavior, Method Area, and Dynamic Tracing with Instrumentation, BTrace, and Arthas
Code Ape Tech Column
Code Ape Tech Column
Jul 10, 2023 · Operations

Fixing SkyWalking ThreadPool Plugin Enhancement Failure by Making AgentClassLoader a Singleton

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.

APMAgentClassLoaderJavaAgent
0 likes · 16 min read
Fixing SkyWalking ThreadPool Plugin Enhancement Failure by Making AgentClassLoader a Singleton
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Jun 26, 2023 · Backend Development

Why SkyWalking’s ThreadPool Plugin Failed and How I Fixed It

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.

ClassLoaderJavaAgentSkyWalking
0 likes · 18 min read
Why SkyWalking’s ThreadPool Plugin Failed and How I Fixed It
Beijing SF i-TECH City Technology Team
Beijing SF i-TECH City Technology Team
May 30, 2023 · Backend Development

Using Bytecode Enhancement in Full-Chain Load Testing Scenarios

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.

ByteBuddyJavaJava Agent
0 likes · 9 min read
Using Bytecode Enhancement in Full-Chain Load Testing Scenarios
Su San Talks Tech
Su San Talks Tech
May 4, 2023 · Backend Development

Unlock JVM Power: Master Java Agent Premain & Agentmain for Runtime Instrumentation

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.

AgentmainBytecode ManipulationJava Agent
0 likes · 21 min read
Unlock JVM Power: Master Java Agent Premain & Agentmain for Runtime Instrumentation
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Apr 21, 2023 · Mobile Development

Android Method Tracing: Implementation and Principles

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.

AndroidAndroid developmentMethod Tracing
0 likes · 9 min read
Android Method Tracing: Implementation and Principles
ITPUB
ITPUB
Apr 10, 2023 · Operations

How Bytecode Enhancement Enables Zero‑Intrusion Monitoring for Microservices

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.

BackendJava Agentbytecode enhancement
0 likes · 18 min read
How Bytecode Enhancement Enables Zero‑Intrusion Monitoring for Microservices
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 16, 2023 · Backend Development

Unlock Non‑Spring AOP with JVM‑Sandbox: A Practical Guide for Java Backend

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.

AOPJVMinstrumentation
0 likes · 17 min read
Unlock Non‑Spring AOP with JVM‑Sandbox: A Practical Guide for Java Backend
ByteDance SYS Tech
ByteDance SYS Tech
Jan 6, 2023 · Fundamentals

How ByteDance Scaled Profile‑Guided Optimization to Boost CPU Efficiency

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.

ByteDancePGOcompiler optimization
0 likes · 12 min read
How ByteDance Scaled Profile‑Guided Optimization to Boost CPU Efficiency
Huolala Tech
Huolala Tech
Dec 27, 2022 · Mobile Development

How to Pinpoint Android App Power Drain with Custom ASM Instrumentation

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.

SensorWakeLockbattery
0 likes · 26 min read
How to Pinpoint Android App Power Drain with Custom ASM Instrumentation
转转QA
转转QA
Nov 9, 2022 · Backend Development

Using JVM‑Sandbox for Exception Injection and Code Enhancement in Java Services

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.

Code EnhancementException InjectionJVM
0 likes · 9 min read
Using JVM‑Sandbox for Exception Injection and Code Enhancement in Java Services
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Sep 21, 2022 · Mobile Development

Optimizing Startup Performance of NetEase Cloud Music iOS App

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.

Binary ReorderingDynamic LibrariesObjective-C++
0 likes · 34 min read
Optimizing Startup Performance of NetEase Cloud Music iOS App
Baidu Geek Talk
Baidu Geek Talk
Sep 14, 2022 · Mobile Development

How Baidu Boosted Android App Startup Using Perfetto and Auto-Instrumentation

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.

AndroidPerfettoPerformance
0 likes · 28 min read
How Baidu Boosted Android App Startup Using Perfetto and Auto-Instrumentation
Baidu App Technology
Baidu App Technology
Sep 5, 2022 · Mobile Development

Automating Android Startup Performance: Perfetto Tracing, Gradle Instrumentation, and Automated Analysis

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.

AndroidGradlePerfetto
0 likes · 30 min read
Automating Android Startup Performance: Perfetto Tracing, Gradle Instrumentation, and Automated Analysis
Alipay Experience Technology
Alipay Experience Technology
Sep 1, 2022 · Mobile Development

How Alipay Optimizes Cold-Start Performance with Spider SDK and APM

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.

APMAndroidcold start
0 likes · 21 min read
How Alipay Optimizes Cold-Start Performance with Spider SDK and APM
JD Tech
JD Tech
Aug 30, 2022 · Fundamentals

Deep Dive into Java Compiler AST Instrumentation for Monitoring

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.

ASTAnnotationProcessingcompiler
0 likes · 17 min read
Deep Dive into Java Compiler AST Instrumentation for Monitoring
JD Retail Technology
JD Retail Technology
Aug 1, 2022 · Backend Development

How Java Compiler AST Injection Eliminates Repetitive Monitoring Code

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.

ASTAnnotation ProcessingJava
0 likes · 16 min read
How Java Compiler AST Injection Eliminates Repetitive Monitoring Code
Java Backend Technology
Java Backend Technology
Jun 10, 2022 · Backend Development

How MemorySafeLBQ Prevents OOM in Java Thread Pools – A Deep Dive

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.

ConcurrencyLinkedBlockingQueueinstrumentation
0 likes · 13 min read
How MemorySafeLBQ Prevents OOM in Java Thread Pools – A Deep Dive
DaTaobao Tech
DaTaobao Tech
May 26, 2022 · Frontend Development

Measuring JavaScript Code Coverage and Reducing Dead Code in Front‑end 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.

Dead CodeTree-shakingcode coverage
0 likes · 11 min read
Measuring JavaScript Code Coverage and Reducing Dead Code in Front‑end Projects
21CTO
21CTO
May 13, 2022 · Backend Development

How Sonic Achieves Near‑Instant Hot Deployment for Java Services

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.

Hot DeploymentIDEA PluginJVM
0 likes · 21 min read
How Sonic Achieves Near‑Instant Hot Deployment for Java Services
Top Architect
Top Architect
Mar 21, 2022 · Backend Development

Understanding Java Object Behavior, Method Area, and Dynamic Tracing with Instrumentation, BTrace, and Arthas

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.

BTraceJavabackend development
0 likes · 16 min read
Understanding Java Object Behavior, Method Area, and Dynamic Tracing with Instrumentation, BTrace, and Arthas
Meituan Technology Team
Meituan Technology Team
Mar 17, 2022 · Backend Development

Sonic: Meituan's Hot Deployment IDEA Plugin – Architecture and Implementation

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.

DCEVMHot DeploymentIDEA Plugin
0 likes · 19 min read
Sonic: Meituan's Hot Deployment IDEA Plugin – Architecture and Implementation
ByteDance Terminal Technology
ByteDance Terminal Technology
Feb 17, 2022 · Mobile Development

DexInjector: Direct APK (dex) Instrumentation Tool and Technical Design

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.

APKAndroidDEX
0 likes · 23 min read
DexInjector: Direct APK (dex) Instrumentation Tool and Technical Design
vivo Internet Technology
vivo Internet Technology
Jan 5, 2022 · Operations

Marko Integrated Code Coverage Platform: Architecture, Features, and Technical Solution

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.

Frontend TestingPlatform Architecturecode coverage
0 likes · 12 min read
Marko Integrated Code Coverage Platform: Architecture, Features, and Technical Solution
Tencent Cloud Developer
Tencent Cloud Developer
Dec 23, 2021 · Cloud Native

An Overview of OpenTelemetry: Origins, Architecture, and Instrumentation

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.

CollectorOpenTelemetrycloud-native
0 likes · 10 min read
An Overview of OpenTelemetry: Origins, Architecture, and Instrumentation
Tech Musings
Tech Musings
Dec 4, 2021 · Backend Development

How Byte Buddy Powers Java Agents: Classloader Tricks and Dependency Solutions

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.

Byte BuddyClassLoaderJava Agent
0 likes · 9 min read
How Byte Buddy Powers Java Agents: Classloader Tricks and Dependency Solutions
ByteDance SE Lab
ByteDance SE Lab
Oct 29, 2021 · Mobile Development

Mastering iOS App Startup: Real‑World Monitoring and Optimization Techniques

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.

Performance MonitoringiOSinstrumentation
0 likes · 28 min read
Mastering iOS App Startup: Real‑World Monitoring and Optimization Techniques
DevOps Cloud Academy
DevOps Cloud Academy
Oct 5, 2021 · Operations

Using the Prometheus Go Client Library to Instrument Go Applications

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.

Gaugecustom-registryinstrumentation
0 likes · 17 min read
Using the Prometheus Go Client Library to Instrument Go Applications
Architect's Alchemy Furnace
Architect's Alchemy Furnace
Sep 11, 2021 · Operations

Mastering Arthas: A Practical Guide to Java Runtime Debugging and 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.

ArthasJavainstrumentation
0 likes · 10 min read
Mastering Arthas: A Practical Guide to Java Runtime Debugging and Monitoring
Architecture Digest
Architecture Digest
Jul 6, 2021 · Operations

Non‑Invasive Production Debugging: An Emerging DevOps Trend

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.

APMDevOpsNon-invasive
0 likes · 13 min read
Non‑Invasive Production Debugging: An Emerging DevOps Trend
58 Tech
58 Tech
May 14, 2021 · Mobile Development

Implementing a Flutter Code Coverage Tool via Dill File Instrumentation

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.

AspectDDillMobile Development
0 likes · 14 min read
Implementing a Flutter Code Coverage Tool via Dill File Instrumentation
Programmer DD
Programmer DD
May 10, 2021 · Backend Development

Mastering Java Dynamic Tracing: Instrumentation, BTrace, and ASM Explained

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.

BTraceBackendJava
0 likes · 16 min read
Mastering Java Dynamic Tracing: Instrumentation, BTrace, and ASM Explained
转转QA
转转QA
Oct 14, 2020 · Mobile Development

Design and Implementation of a Code Coverage Solution for the Zhuanzhuan Mobile App

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.

Androidbackend servicecode coverage
0 likes · 12 min read
Design and Implementation of a Code Coverage Solution for the Zhuanzhuan Mobile App
Amap Tech
Amap Tech
Sep 14, 2020 · Operations

JaCoCo Code Coverage Instrumentation Principles and Practices for Android SDK

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.

ASMAndroidJaCoCo
0 likes · 17 min read
JaCoCo Code Coverage Instrumentation Principles and Practices for Android SDK