This article explains how to identify and troubleshoot the four main resource bottlenecks—CPU, memory, disk I/O, and network—by detailing Linux internals, key metrics, practical command examples, real‑world case studies, and a step‑by‑step decision tree for accurate diagnosis and tuning.
The article explains how to safely add indexes to a tens‑of‑millions‑row MySQL table, covering lock duration, disk‑space impact, write‑performance degradation, and six practical principles—selective columns, proper order, covering indexes, avoiding redundancy, short‑lock tools, and ongoing monitoring—plus pros, cons, and suitable use cases.
When a service’s P99 latency spikes to seconds and CPU hits 90% without logs, Arthas lets you inspect the JVM in real time without code changes, and its AI‑driven MCP extension automates command selection, enabling developers to diagnose, trace, decompile, and monitor issues through simple natural‑language prompts and Spring Boot integration.
The article explains how mobile network performance issues—especially long connection‑pool wait times—cause slow page loads in Android apps, demonstrates how to interpret Alibaba Cloud RUM’s Resource event metrics and timing data, walks through a real‑world case study with detailed stage‑by‑stage analysis, and provides concrete diagnostic steps and optimization recommendations for OkHttp connection‑pool configuration and other common bottlenecks.
This article explains how mobile network diversity, device fragmentation, and limited visibility make performance troubleshooting hard, then introduces Alibaba Cloud RUM's Resource event model, walks through its attribute and metric fields, demonstrates a real‑world Android case study with step‑by‑step timing analysis, and provides concrete diagnosis and optimization guidelines for connection‑pool, DNS, SSL, and TTFB issues.
This article details JD.com’s six‑month engineering effort to refactor its high‑traffic order module into a single Taro codebase that runs on Android, iOS and HarmonyOS, covering business background, preparation, multi‑mode adaptation, core challenges, quality assurance, efficiency gains and the resulting business impact.
The article shows how to replace repetitive System.currentTimeMillis() timing code with a concise TimeTracker utility that leverages try‑with‑resources, functional interfaces, and flexible exception handling to achieve millisecond‑level measurement and dramatically improve code readability and performance.
The article explains Linux's core storage components—inode, dentry, superblock, and logical blocks—how the Virtual File System abstracts different file systems, the classification of file systems and I/O types, disk technologies, the block layer, I/O schedulers, and practical performance metrics and monitoring tools.
This guide walks Linux operators through the fundamentals of memory management, explains key metrics, and provides step‑by‑step instructions for using tools like top, free, vmstat, pmap, valgrind, smem, smaps and slabtop to pinpoint and resolve memory leaks and excessive memory consumption in production systems.
This article walks through designing and implementing a complete JMeter load‑testing solution for an e‑commerce platform's big‑sale scenario, covering business‑flow mapping, request correlation, multi‑stage stress testing, real‑time monitoring with InfluxDB + Grafana, bottleneck identification, and practical optimization tips.
This article introduces MyPerf4J, a Java‑agent based, low‑overhead performance monitoring tool that provides real‑time metrics such as RPS, latency percentiles, memory usage and GC statistics, and explains how to install, configure, run and uninstall it in development and production environments.
This article presents a comprehensive case study on unifying multiple legacy backend systems by building a modern Vue‑based front‑end, combining native iframe integration with the qiankun micro‑frontend framework to achieve a single entry point, smooth migration, reduced costs, and an evolvable architecture for enterprise applications.
This article explains essential Linux commands for programmers, covering user management, system administration, and performance monitoring, describes how Linux treats everything as a file, distinguishes Linux and shell commands, and suggests learning 10‑20 commands daily, with visual examples.
A production incident shows a server with 80% CPU usage but a Load Average over 40, revealing that high load often stems from IO wait and soft interrupts rather than CPU saturation, and provides a step‑by‑step troubleshooting guide using top, vmstat, iostat and ps.
This article explains how to evaluate and improve Apache Weex applications by using built‑in performance monitors, defining essential metrics such as first‑screen render time and interaction latency, and applying ten practical testing and optimization techniques for both iOS and Android platforms.
This article explains why many enterprises lack quantitative architecture efficiency metrics, outlines the multidimensional challenges of assessing technical, business, cost, and organizational performance, and provides a detailed, step‑by‑step KPI framework—including technical, business, cost, and organizational indicators, data collection automation, monitoring dashboards, and continuous improvement practices—to enable data‑driven architecture optimization.
This article walks through a real‑world Android crash investigation, showing how to collect, visualize, and analyze crash data with Alibaba Cloud RUM, trace user behavior, identify the root cause in ProductListAdapter, and apply symbolication and version comparison to resolve the issue efficiently.
This comprehensive guide walks you through Linux system performance monitoring using tools like top, htop, vmstat, iostat, sar, netstat, ps, and free, explains each metric, provides practical shell scripts for real‑time analysis, alerts, and detailed tuning strategies for CPU, memory, disk, and network.
This article explains the key CPU performance metrics on Linux—including load average, CPU usage percentages, and process states—showing how to interpret top, ps, uptime, and mpstat outputs and how to differentiate between load and utilization in various workload scenarios.
This guide walks through configuring MySQL slow query logging, using Logstash to ingest and parse logs, storing them in Elasticsearch, visualizing with Kibana dashboards, and setting up alerts for real-time performance monitoring.
MyPerf4J is an open‑source, high‑performance Java monitoring and statistics tool that uses a JavaAgent for zero‑intrusion, records up to ten million method calls per second with nanosecond precision, and provides real‑time metrics such as QPS, latency percentiles, memory and GC stats, making it ideal for both development and production environments.
This article presents twenty indispensable Linux command‑line tools—covering system monitoring, performance analysis, process management, network diagnostics, disk handling, and kernel tuning—explaining their syntax, practical tips, common pitfalls, and how they integrate with modern cloud‑native environments.
This guide explains Linux disk performance indicators—utilization, saturation, IOPS, throughput, and latency—their interrelationships, and how to monitor both overall and per‑process I/O using tools like iotop, pidstat, and the /proc filesystem.
Explore the comprehensive suite of built‑in and third‑party JVM tools—including jps, jstack, jmap, jcmd, JConsole, VisualVM, async‑profiler, Arthas, MAT, JProfiler, and APM solutions—detailing their core features, common commands, and practical use‑cases for monitoring, diagnosing, and optimizing Java applications in development and production.
The article explains how Alibaba Cloud’s OS console implements a one‑click IO diagnostic that automatically detects, classifies, and resolves high‑latency, burst, and iowait IO issues in multi‑tenant cloud environments by using dynamic thresholds, periodic metric collection, and targeted root‑cause analysis.
This article explains why resource over‑commit in cloud‑native Kubernetes clusters leads to memory and CPU latency, shows how to visualize kernel delays with the ack‑sysom‑monitor exporter, outlines common latency scenarios, and provides step‑by‑step troubleshooting and remediation guidance.
This tutorial explains how to leverage Linux kernel tracepoints with eBPF and bpftrace to capture real‑time GPU driver activity—including job scheduling, memory management, and command submission—across Intel, AMD, Nouveau, and NVIDIA GPUs, providing detailed examples, scripts, and analysis of the resulting data.
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 guide covers Linux performance analysis tools—including top, htop, iotop, pidstat, iostat, sar, and vmstat—detailing installation, usage, key metrics, troubleshooting scenarios, monitoring integration with Prometheus, and best‑practice recommendations for effective system diagnostics and capacity planning.
This article introduces ten widely used Alibaba‑developed Java tools—including the Java Initializr scaffolding service, Arthas diagnostic utility, Dragonwell JDK, code‑style scanner, ARMS monitoring platform, PTS performance tester, AHAS high‑availability suite, EasyExcel, HandyJSON, and the Druid connection pool—highlighting their features, use cases, and links to official sites.
Mobile developers often struggle with unreproducible crashes and lag reported by users, spending days sifting through logs and isolated stack traces; this article explains how a cloud‑native iOS SDK links performance metrics, error logs, and user behavior through systematic data collection to dramatically speed up issue diagnosis.
Linux memory management relies on virtual address spaces that map to physical RAM, using page tables, multi-level paging, and dynamic allocation across segments like stack, heap, and mmap, while tools such as free, top, and ps let administrators monitor usage and handle OOM scenarios.
The article explains the architecture, data collection methods, and crash monitoring techniques of Alibaba Cloud's RUM SDK for iOS, detailing session tracing, performance metrics, Method Swizzling, system event handling, and KSCrash integration to improve issue diagnosis.
Koin Annotations 2.2 introduces JSR‑330 compatibility, predefined scope archetypes, smart module configuration, and built‑in performance monitoring, enabling Android and Kotlin Multiplatform projects to migrate from Dagger or Hilt to Koin safely, progressively, and with minimal code changes.
This guide provides a comprehensive collection of essential MySQL commands covering database creation, table schema management, data manipulation, user permissions, performance monitoring, and backup/restore procedures, offering a practical reference for developers and administrators.
This article introduces five essential Linux performance monitoring commands—vmstat, iostat, free, df, and sar—detailing their purpose, key options, example usages, and the meaning of each output column to help you effectively track system resources.
This article introduces HarmonyOS NEXT's pure, fast, and minimal design, its development base with DevEco Studio and ArkTS, the compilation artifacts (HAR, HSP, HAP), the system‑level open capability map, and the ARMS RUM SDK's architecture, session management, and three unobtrusive data‑collection schemes for performance monitoring.
The article explains why RAGFlow needs end‑to‑end link tracing, introduces OpenTelemetry’s core concepts, shows how custom tracing utilities are implemented in Python, describes the layered architecture, provides concrete Docker and YAML configurations, and offers best‑practice guidelines for performance monitoring and fault diagnosis.
This article explains how to design a lightweight, flexible Java TimeTracker utility that leverages AutoCloseable, try‑with‑resources, functional interfaces and lambda expressions to simplify performance monitoring, support automatic exception handling, and provide extensible features for real‑world backend development.
Master Linux system performance by learning ten powerful monitoring commands—top, vmstat, lsof, iotop, iostat, htop, netstat, iftop, tcpdump, and nethogs—each illustrated with usage examples and output, enabling quick diagnosis of CPU, memory, disk, and network issues.
Go 1.25 introduces Trace Flight Recorder, a lightweight circular‑buffer tracing tool that lets developers capture recent execution data in production with minimal overhead, and the article walks through its concepts, configuration, code demos, analysis workflow, and practical use cases.
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 explains what QPS (queries per second) really means, distinguishes it from TPS and concurrency, shows typical QPS ranges for different systems, and provides practical methods—production monitoring, APM tools, custom metrics, load‑testing and manual estimation—to obtain, validate, and interpret QPS for performance optimization and interview success.
This comprehensive guide walks you through why tcpdump is essential for ops engineers, how to install and configure it, basic and advanced filtering commands, real incident case studies, performance tuning, security analysis, and integration with other tools, turning raw packet captures into actionable insights.
This article explains five practical ways to count QPS—from gateway and application instrumentation to monitoring tools, log analysis, and database metrics—while highlighting common pitfalls such as health‑check filtering, thread‑safety, and multi‑node aggregation, helping engineers make informed scaling decisions.
This article explains the concept of distributed link tracing, its principles, metrics, and implementation details—including monolithic and microservice approaches, OpenTracing standards, and how SkyWalking solves challenges like automatic span collection, context propagation, unique trace IDs, and sampling performance.
This article explains why load testing is essential for modern applications that must serve millions of users, outlines various test types and best‑practice steps, recommends tools and frameworks, and shows how continuous testing integrated into CI/CD pipelines ensures scalability, reliability, and optimal performance under unpredictable traffic spikes.
When a Linux server shows performance issues, this guide walks you through the most important one‑minute metrics—using commands like uptime, dmesg, vmstat, mpstat, pidstat, iostat, free, sar and top—to quickly pinpoint CPU, memory, I/O, and network bottlenecks.
This guide presents twenty practical Linux disk‑management techniques—from basic inspection commands like lsblk and blkid to advanced LVM, RAID, and performance‑monitoring tools—providing step‑by‑step examples, command syntax, and best‑practice recommendations for reliable storage administration.
Meteor, built on Alibaba's Arthas, is a non‑intrusive Java diagnostic console that lets developers monitor running applications, locate performance bottlenecks, memory leaks, and thread deadlocks without restarting services, offering a SpringBoot‑based architecture, quick start commands, and features such as class inspection, live code editing, method monitoring, thread management, and dashboards.
This article walks through a real‑world 100% CPU incident on an e‑commerce platform, showing how to detect the problem within seconds, analyze Java threads, apply quick emergency fixes, implement permanent refactoring, and set up long‑term monitoring to prevent future outages.
Network latency spikes often leave developers guessing whether the culprit lies in user‑space, the kernel stack, or the physical link; this article introduces TencentOS’s NBS (Net Blackboard System), a low‑overhead, zero‑disruption solution that pinpoints delay sources, supports continuous deployment, and outperforms traditional tools like tcpdump and bpftrace.
This article details how test development engineers tackled CDN stability challenges by implementing a dual overseas architecture, automated backend interface validation, and a data‑driven front‑end image detection pipeline, achieving an 80% efficiency gain and minute‑level issue detection.
This guide explains the fundamentals of memory leaks in Java, outlines common causes in Spring Boot, and provides step‑by‑step techniques—including GC log analysis, JConsole, VisualVM, MAT, Actuator, custom endpoints, jstack, BTrace, and best‑practice recommendations—to identify, diagnose, and prevent memory leaks for stable long‑running services.
This guide introduces a comprehensive set of Linux performance monitoring utilities—including vmstat, iostat, dstat, iotop, pidstat, top, htop, mpstat, netstat, ps, strace, uptime, lsof, and perf—explaining their purpose, key options, and example commands for effective system analysis and optimization.
This guide introduces JVM performance monitoring by explaining built‑in tools like JConsole and VisualVM, showcasing third‑party solutions such as Arthas, and providing step‑by‑step commands and screenshots to help developers quickly visualize and troubleshoot Java applications.
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.
Learn how to quickly pinpoint MySQL performance bottlenecks on AlmaLinux by using built‑in tools like top, iotop, ss, and netstat, and automate snapshot collection with a simple Bash script that records system and container metrics for later analysis.
This article explains what CPU steal time is, how to view it with the GNU top command, why it occurs in virtualized environments, and provides practical guidelines for interpreting and addressing high steal‑time values to ensure stable cloud VM performance.
This comprehensive guide explains how to monitor, diagnose, and resolve Linux server performance bottlenecks by covering essential command‑line tools, logging, automated scripts, and optimization techniques for CPU, memory, disk I/O, and network, with practical case studies and code examples.
This article explains key performance metrics such as API latency, SLA commitments, and percentile indicators P90, P95, and P99, illustrating how to calculate and interpret these values along with average and maximum latency to improve system reliability and user experience.
The article explains what page faults are, how the Linux kernel handles them, methods to measure their frequency with tools like perf, vmstat and ftrace, and discusses why frequent faults degrade performance and how to mitigate them through memory, configuration, and code optimizations.
This article explains how to build and use a Java StackTrace utility that extracts and filters method call chains, enabling developers to quickly locate error sources, streamline debugging, and improve operational efficiency by visualizing execution paths through customizable parameters and integration examples.
Locust provides a built‑in web UI for real‑time monitoring of metrics such as RPS, average response time, failures, and active users, supports headless CSV export for deeper analysis, and allows custom statistics via event listeners in your test scripts, enabling comprehensive user access reporting.
This guide explains how to use the Linux /usr/bin/time utility to measure program resource usage—including user and kernel CPU time, memory consumption, and I/O statistics—covers its syntax, common options, custom format strings, and the distinction between the external command and the shell built‑in.
This article introduces five Linux commands—vmstat, iostat, free, df, and sar—explaining their purpose, common options, example usages, and the meaning of each column in their output to help you monitor memory, CPU, I/O, and filesystem performance in real time.
This guide explains how to monitor key system resources such as CPU, memory, battery, network traffic, and startup time during Android Monkey testing, provides ADB commands for data collection, and offers a structured test report template with practical steps for automation and analysis.
This article explains Application Performance Monitoring (APM), its key benefits such as business continuity, performance optimization, and cost reduction, outlines essential APM modules, and details Yunzhou Observation’s OpenTelemetry‑based design, data ingestion, processing, visualization, and future roadmap for observability.
This article explains the unique observability challenges of large language model (LLM) applications, outlines essential performance, cost, and safety metrics, and presents a comprehensive cloud‑native solution—including trace, metric, and log collection, domain‑specific dashboards, and step‑by‑step integration with Alibaba Cloud's Python Agent—to ensure reliable, efficient LLM deployments.
This article explains what Linux context switching is, details the information stored in a process control block, distinguishes between process, thread, and interrupt context switches, and shows how to monitor them using vmstat and pidstat commands.
When a Linux server shows performance problems, this guide walks you through the essential commands—uptime, dmesg, vmstat, mpstat, pidstat, iostat, free, sar, and top—explaining what each metric reveals and how to interpret the output to quickly narrow down the root cause.
This article explains the importance of frontend performance monitoring, outlines core metrics such as FCP, LCP, FP, CLS, and demonstrates how to implement a comprehensive SDK using PerformanceObserver, custom configuration, and wrappers for fetch and XMLHttpRequest to capture resource and network data for batch reporting.
This article presents a lightweight, non‑intrusive eBPF‑based method for instantly identifying Redis big‑key operations, explains the underlying kernel and user‑space implementation, provides complete code samples, and evaluates performance before and after optimization.
The article introduces Cool Request, an IDEA plugin that now supports a Trace feature for measuring execution time of any method, automatic MyBatis function tracing, customizable duration coloring, and script-based environment manipulation, complete with usage examples and code snippets.
This guide explains how to leverage Locust's built‑in statistics and reporting features to monitor HTTP requests in real time via its web UI, export results as CSV files, customize metric collection in scripts, and analyze the data with external tools.
The article explains Locust's event system, detailing common events such as init, test_start, test_stop, request_success, request_failure, quitting, worker_report, and hatch_complete, and provides Python code examples for attaching listeners to customize load‑testing behavior.
This article presents a systematic root‑cause diagnosis framework for online applications, covering how to identify and resolve both error ("wrong") and performance ("slow") problems using trace links, associated data, high‑quality observability, and large‑language‑model‑driven intelligence.
This article explains the principles and benefits of distributed tracing, introduces OpenTracing and SkyWalking architecture, and shares practical implementations and performance comparisons that help identify bottlenecks in microservice systems.
This tutorial shows how to use an eBPF program with the PERF_EVENT type to trace kernel activity, collect samples via performance counters, and pinpoint which processes and functions consume the most execution time, covering dynamic tracing concepts and overflow handling.
This article demonstrates how to write an eBPF program that attaches to Linux soft‑interrupt entry and exit points, records timestamps in eBPF maps, computes handling duration, updates counters and histograms, and exposes the data to user space for performance analysis.
The article explains how Chrome's Recorder feature lets developers capture, replay, edit, and export user interaction flows, turning repetitive manual testing into a one‑click process that speeds up debugging, performance monitoring, and automated test creation.
This article explains how to use essential Linux commands such as uptime, dmesg, vmstat, mpstat, pidstat, iostat, free, sar, and top to monitor system load, CPU usage, memory, I/O, and network activity, interpreting their outputs for effective troubleshooting.
This article provides a comprehensive guide to Python decorators, covering their basic concepts, practical examples including logging, multiple decorators, parameterized decorators, metadata preservation, class decoration, and performance monitoring applications.
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.
When testing Linux server performance, you should monitor key metrics such as CPU usage, memory consumption, disk I/O, network bandwidth, process information, file system usage, system logs, boot and response times, context switches, and interrupts, using tools like top, vmstat, iostat, netstat, and custom Python scripts.
This guide presents eight practical MongoDB shell scripts—covering database size analysis, connection monitoring, long‑running query termination, table‑scan detection, replica‑set health checks, and slow‑query profiling—plus usage tips and cautions for reliable administration.
This article explains why operations metrics are vital for businesses, describes how tracking availability, failure rate, MTTR, MTBF, response time, throughput, error rate, capacity utilization, latency, data integrity, backup success, recovery time, security patch time, server and network utilization can improve reliability, reduce costs, and boost competitiveness.
This article introduces Arthas, an open‑source Java diagnostic tool, and demonstrates how to install it, use its command‑line and web console, and apply common commands such as dashboard, thread, watch, trace, and tt to quickly locate CPU spikes, deadlocks, memory leaks, and other production problems without redeploying code.
This tutorial shows how to use eBPF, bpftrace, and the funclatency tool to instrument key Nginx functions, measure their execution latency, analyze the distribution of request processing times, and identify performance bottlenecks for optimization.
This guide walks through real‑world scenarios of high CPU and memory alerts, demonstrating how to use Linux's top tool, interpret its detailed output, convert thread IDs, and leverage jstack dumps to pinpoint and resolve performance bottlenecks.
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.
The article presents MyPerf4J, a Java‑agent based, low‑overhead performance monitoring library that provides real‑time metrics such as method latency, QPS, memory usage, GC statistics, and class loading, along with quick‑start instructions, configuration details, and open‑source links for Java backend services.
To solve duplicated functionality, legacy code, and scalability limits in Bilibili’s live‑streaming interaction services, the team created a unified Interaction Center that abstracts RTC, consolidates session, link, UI, scoring and role management, introduces a shared state machine and tracing, and evolves through phased, extensible architecture for higher performance and maintainability.
This guide explains how to monitor memory usage on Linux servers, identify common causes of sudden memory consumption such as leaks, stuck processes, or high load, and provides concrete commands and remediation steps to stabilize system performance.
By deploying eBPF agents as DaemonSets that hook kernel network and performance events, the Xiaohongshu observability team extended cloud‑native monitoring from the application to the kernel, delivering real‑time traffic analysis and low‑overhead continuous profiling for C++ services, aggregating data into centralized collectors for dashboards, flame‑graphs, and rapid root‑cause diagnosis.
This article walks through creating a first eBPF program using C and Go on Ubuntu 22.04, covering required dependencies, kernel‑space vs user‑space concepts, event selection, BPF map definition, and a tracepoint function that measures per‑process CPU time.
The team built a cross‑platform real‑time troubleshooting system for live streaming that adds critical‑business monitoring and a unified trace_id‑based tracing framework, simplifies OpenTracing, iterates reporting components, handles multi‑threading, stitches telemetry into searchable event chains, and via dashboards cut diagnosis time from two hours to five minutes, achieving a 91% fault‑resolution rate.
This guide explains how to use the Linux /usr/bin/time utility to analyze program performance—including user and kernel CPU time, memory usage, and other resources—by invoking the command with various options, customizing output formats, redirecting results, and distinguishing it from the shell built‑in time command.
MyPerf4J is a high‑performance, non‑intrusive Java Agent that records millions of method calls per second with nanosecond precision, offering real‑time metrics, low memory overhead, and comprehensive monitoring for both development and production environments.
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.
