Kudu is an MIT-licensed open-source desktop toolkit that combines system cleaning, security scanning, and performance monitoring for Windows, macOS, and Linux, featuring local-only operation, no ads, JSON-defined cleaning rules, CLI and GUI modes, and privacy-focused design.
This article categorizes essential Linux commands for Java developers, explains why interviewers focus on real‑world usage, provides scene‑based command tables, demonstrates log‑analysis and performance‑monitoring workflows, and offers concise answers to common interview follow‑up questions.
This guide explains how to use the Linux tools top, vmstat, and iostat to systematically identify CPU, memory, or disk I/O bottlenecks on a server that becomes progressively slower, offering step‑by‑step analysis, example scenarios, and practical optimization advice.
The article presents a four‑layer method for diagnosing sudden Redis memory growth, covering recent releases or configuration changes, key monitoring metrics, sampled key analysis, and emergency mitigation steps, with concrete metric definitions and practical examples.
This article compiles a comprehensive guide to Linux performance analysis utilities, covering basic commands like vmstat, iostat, dstat, top, htop, and advanced tools such as perf, eBPF, Flame Graphs, and sar, with usage examples, output explanations, and practical tips for system monitoring and tuning.
This article details HarmonyOS Application Performance Monitoring Service (APMS) fault metrics, explaining access via AppGallery Connect, four core functions — metric query, version comparison, dimension distribution, and TOP problem aggregation — and how real-time crash, freeze, OOM, and resource leak data enable proactive app health inspection.
When a production service shows 100% CPU usage, this guide walks you through a rapid three‑minute workflow—identifying the affected scope, distinguishing user, system, iowait, steal and softirq metrics, and using Linux, systemd, Docker/Kubernetes and language‑specific tools to pinpoint the offending process, thread, or system call before taking corrective actions such as throttling, scaling, or rolling back.
This guide presents a systematic, ten‑step Linux command workflow—from overall system health to process, I/O, and log analysis—helping operators quickly determine whether a problem persists, which resource (CPU, memory, disk, network) is affected, and whether enough evidence exists to safely remediate.
This article walks through the principles of database connection pools, common causes of pool exhaustion such as leaks, mis‑configuration, slow SQL and DB limits, and provides a step‑by‑step methodology with monitoring, thread‑stack analysis, and concrete configuration and SQL optimizations to restore stability.
The article analyzes how modern Node.js services act as a convergence layer for HTTP, databases, caches, RPCs, and AI calls, making performance problems cross‑layer, and introduces Alibaba Cloud ARMS Node.js probe that, with a single integration, automatically gathers APM, AI observability, runtime health, and dynamic configuration to provide full‑stack tracing and simplify troubleshooting.
This guide explains how tcpdump, built on libpcap and the kernel BPF filter, can capture packets at the network stack, compares it with Wireshark, shows practical filtering syntax, performance considerations, typical use‑cases such as TCP retransmission, DNS timeouts and TLS handshake failures, and provides scripts and best‑practice recommendations for production‑grade troubleshooting.
Android 17 enhances Binder observability with a lock-free SPSC queue, boot-stable sharding, exponential latency histograms, and CPU sampling in the user-space Observer V2, while introducing a kernel Netlink channel for asynchronous, zero-overhead IPC error events like frozen transactions and spam detection.
This article presents a systematic, evidence‑driven process for locating and resolving high CPU usage on Linux servers, covering environment preparation, layered troubleshooting from whole‑machine to thread level, concrete command examples, real‑world case studies, best‑practice recommendations, and monitoring configurations.
This guide lists the most frequently used MySQL commands for checking version, connections, process lists, killing queries, global status, configuration variables, lock waits, slow‑query settings, table sizes, index information, execution plans, and replication status, each with practical usage scenarios.
This guide demonstrates seven bytecode instrumentation scenarios using HarmonyOS AbcKitTS, including lifecycle tracking, function timing, privacy API monitoring, method replacement, attribute modification, click tracking, and parameter validation, with code examples and Hvigor plugin integration.
This guide walks you through a step‑by‑step, non‑disruptive workflow for diagnosing high disk I/O on Linux servers using built‑in tools such as vmstat, iostat, iotop, pidstat, lsof and the low‑level tracer blktrace, then shows how to interpret the data, identify common root causes, apply targeted fixes, and verify improvements with fio benchmarks and continuous monitoring.
Faced with massive MyBatis log files that made manual slow‑SQL hunting impossible, the author designed a SpringBoot‑Vue‑MySQL system that parses logs with multithreaded batch processing, flexible regex templates, real‑time performance monitoring, and virtual‑scroll UI, achieving 55 000 lines/s throughput and over 95% matching accuracy.
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.
After a system has been running, developers often drown in manual log statements to answer questions like why an interface is slow, who called a method, or what parameters were passed, but Spring Boot AOP lets you replace all that with a single annotation and aspect that automatically records calls, execution time, parameters, exceptions, and call chains, keeping business code clean.
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.
The 2025 monitoring report by AIIA and the China Academy of Information and Communications Technology evaluates 42 large‑model services across 13 MaaS platforms, revealing near‑100% call success rates, significant TPS growth, sub‑second latency, increasing open‑source model adoption, and a gradual decline in service pricing.
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.
CPU Steal TimePerformance Monitoringcloud computing
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.
Performance MonitoringRoot Cause Analysiscloud monitoring
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.
Linux profilingPerformance Monitoringdynamic tracing
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.