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.
This article explains how to produce Lua‑level flame graphs for OpenResty by leveraging SystemTap’s lj‑lua‑stacks tool, demonstrates the underlying data structures and call‑stack extraction, and explores a possible eBPF‑based rewrite for safer, kernel‑level tracing.
This guide shows how to enable detailed request/response logging, measure controller execution time, and customize 404 error responses in Spring Boot 3.2.5, providing practical code snippets and configuration tips for effective backend debugging and monitoring.
This article explores why Large Contentful Paint (LCP) often lags behind overall performance scores, explains how to measure LCP using ProductionObserver and web‑vitals, and presents a detailed case study with code snippets and actionable strategies to reduce LCP below 2.5 seconds.
This guide explains three common ways to output MyBatis SQL statements and their execution times—using simple configuration logging, a custom MyBatis interceptor plugin, and the third‑party p6spy library—along with code examples and practical considerations for development and production environments.
The latest update of the Cool Request IDEA plugin introduces a powerful Trace function that automatically records execution times for any method—including Spring @Scheduled and xxl‑job tasks—offers customizable latency coloring, MyBatis SQL timing, call‑count indicators, and scriptable environment variables for seamless token handling and JSON parsing.
This guide outlines key operational metrics—availability, failure rate, MTTR, MTBF, response time, throughput, error rate, capacity utilization, latency, data integrity, and more—explaining their calculations, typical benchmark values, and practical application areas to help organizations monitor and improve IT performance.
DevOps engineers must master programming and scripting, configuration and version control, deployment across hardware and cloud, security practices, performance monitoring, network optimization, and effective communication and team management to ensure rapid, reliable software delivery.
The article presents a visual monitoring system for the Caffeine Java cache that adds instance naming, memory‑usage estimation, dynamic size and expiration configuration, real‑time statistics and data queries, and a Jetty‑based HTTP control panel, enabling global cache management, trend charts, and on‑the‑fly cache invalidation.
This article details the deployment of QUIC in Trip.com’s mobile app, covering multi‑process architecture, containerized upgrades, service discovery, health monitoring, push‑pull resilience, full‑link tracing, congestion‑control algorithm redesign, and the resulting performance and reliability improvements achieved across global users.
This article explains the fundamentals of distributed tracing in microservice environments, introduces OpenTracing standards, details SkyWalking's architecture and sampling strategies, evaluates its performance against competitors, and shares practical company adaptations such as custom plugins, forced sampling, and trace ID logging.
pfinder, JD’s in‑house APM system, provides full‑link monitoring, multi‑dimensional metrics, automatic instrumentation, topology mapping, trace analysis, AI‑driven fault detection by leveraging bytecode enhancement techniques such as ASM, Javassist, ByteBuddy and ByteKit, and integrates with JVM agents for hot‑deployment and trace propagation.
This article provides a comprehensive technical overview of JD's self‑built PFinder APM system, detailing its core concepts, multi‑dimensional monitoring capabilities, bytecode‑enhancement mechanisms using ASM, Javassist, ByteBuddy and ByteKit, JVMTI‑based agents, service and plugin loading, trace‑ID propagation across threads, and a prototype hot‑deployment solution.
This article introduces eBPF, explains its zero‑intrusion observability advantages, describes its architecture and runtime workflow, outlines development prerequisites and compilation steps, and provides concrete Go‑based examples for tracing bash commands and measuring TCP connection latency.
The article describes a unified front‑end observability platform that standardizes data‑point collection via a common SDK, automatically generates health and business dashboards, integrates real‑time monitoring and heatmaps, and has been adopted on 140 pages, delivering faster first‑screen loads, lower error and bounce rates, and higher conversion.
This article details the design and implementation of QQ’s Hodor performance‑degradation prevention system, covering its motivation, architecture, data collection via xctrace, task scheduling, static symbol scanning, automated ticketing, alerting, dashboards, and the measurable efficiency gains achieved across the mobile client ecosystem.
This article outlines the challenges of front‑end performance troubleshooting for a 2D design tool, proposes systematic approaches for identifying issues, describes monitoring metrics such as load time and frame rate, and presents real‑world case studies demonstrating effective optimization and baseline management.
This article explains how to monitor and improve website performance in PHP by measuring script execution time, memory usage, database query efficiency, code execution, and HTTP request latency, and provides practical code examples for each technique.
CPU efficiency depends on low CPI and high cache‑hit rates, which can be measured on Linux using the high‑level perf utility or the low‑level perf_event_open syscall to read hardware performance counters for cycles, instructions, and cache‑miss statistics, revealing how often the processor falls back to slower memory.
This article introduces Arthas, an open‑source Java diagnostic tool from Alibaba, explains its key features, shows how to install it via Maven, and provides step‑by‑step commands for entering the shell, monitoring JVM status, tracing method calls, observing system resources, dynamically redefining code, and connecting to applications using default or Telnet modes.
This article introduces a range of essential Linux performance analysis utilities—including vmstat, iostat, dstat, iotop, top/htop, mpstat, netstat, ps, strace, uptime, lsof, perf, and sar—explains their core options, shows example commands, and clarifies which metrics each tool reports to help engineers monitor and troubleshoot system behavior.
An in‑depth guide shows how to build a client‑side dynamic degradation framework for iOS and Android that monitors CPU, memory, battery and network speed, classifies them into levels, and notifies the business layer to adapt UI and network usage for smoother user experience.
QQ 9 achieves a “silky smooth” experience by cutting launch time 40% through lazy‑loaded libraries and main‑thread priority tweaks, boosting runtime fluidity with an NT Kernel that offloads logic, incremental diff refreshes and parallel layout, and adding the Hodor anti‑degradation system, delivering 35% smoother performance and 48% less lag.
The team successfully employed eBPF dynamic tracing to obtain full Java call‑stack traces from any point in an OpenJDK 8 JVM process with microsecond‑level overhead, without requiring any JVM agents, bytecode injection, or code modifications, making it suitable for production environments.
This guide explains the importance of application monitoring and error tracking in Laravel, introduces Sentry’s features, and provides step‑by‑step instructions for installing, configuring, and customizing Sentry—including error reporting, performance monitoring, real‑time notifications, and advanced integration options—to improve stability and user experience.
The article details NetEase Cloud Music’s end‑to‑end, online‑configurable data‑consumption service and schema‑driven visualization platform that transform raw client logs into ClickHouse records, automatically generate tables and dashboards, and provide observability, dramatically reducing manual effort while supporting over twenty performance metrics for frontend monitoring.
The article explains the principles and benefits of distributed tracing, introduces OpenTracing standards, details SkyWalking’s architecture and sampling strategies, compares its performance with Zipkin and Pinpoint, and shares practical implementation experiences and custom plugin development within a micro‑service environment.
This article explains Linux networking fundamentals, covering the OSI and TCP/IP models, the Linux network stack layers, packet encapsulation, MTU considerations, and practical commands such as ifconfig, ip, netstat, ss, and ping for performance monitoring and troubleshooting.
This guide explains how Alibaba Cloud's ARMS error/slow trace analysis feature can automatically compare abnormal and normal traces to identify root causes such as host, interface, slow SQL, or message‑queue issues, providing step‑by‑step examples for real‑world e‑commerce scenarios.
The article details how systematic refactoring, bundle compression, asynchronous initialization, pre‑heating, and targeted runtime profiling reduced the Electron‑based Taobao Live PC client’s launch time from ten seconds to 2.5 seconds, streaming page start to 50 ms, and CPU load from 13 % to 6.7 % while adding power‑management fallbacks.
This article reviews GaussDB(DWS) TopSQL, explaining its purpose, core principles, configurable parameters, system tables, typical real‑time and historical use cases, and practical tips for using TopSQL to monitor, diagnose, and optimize SQL workloads in production environments.
This guide explains how to choose Linux I/O schedulers, generate realistic storage workloads with fio, configure various RAID levels using mdadm and LVM, and monitor performance with tools like top, iostat, iotop, blktrace, and atop, providing practical command examples and best‑practice recommendations.
This article explains how to use reflection and dynamic proxies to hook the hidden Android Looper.Observer API for detailed message‑dispatch timing, demonstrates code examples for installing and removing the hook, discusses workarounds for hidden‑API restrictions and the .dex loading changes introduced in Android 14.
This article explains the concept of distributed tracing, outlines its underlying principles in Java, details step‑by‑step implementation using popular SDKs, and describes common application scenarios such as performance monitoring, fault diagnosis, complex event handling, traffic analysis, and system optimization.
This article explains the principles and benefits of distributed tracing systems, introduces OpenTracing standards, details SkyWalking’s architecture and mechanisms for automatic span collection, context propagation, unique trace IDs, sampling strategies, and performance impact, and shares practical implementation experiences and custom plugin development within a real‑world microservice environment.
This guide explains how to use the Linux top command to monitor real‑time process changes, interpret system and process statistics, apply command‑line options, perform common interactive operations, and understand CPU steal time for virtualized environments.
This article guides you through installing BCC, creating simple and complex eBPF programs with C and Python, explains eBPF architecture, source‑code organization, and demonstrates real‑world tracing examples for kernel diagnostics and performance monitoring.
This article explains how to use Android's hidden Looper$Observer API via reflection and dynamic proxies to monitor long‑running messages on the main thread, classify their execution time, and bypass hidden‑API restrictions, with complete code examples and practical tips for Android 10‑14.
This article details the complete redesign of our internal APM system, covering the motivations, architecture choices, metric collection pipeline, integration of VictoriaMetrics and VMAlert, metric and alert design principles, implementation steps, visualizations, performance gains, and future plans for scaling and SaaS‑ification.
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.
The Java service crashed when the Linux OOM killer terminated its process after a developer opened a 37 GB log file with Vim, which loaded the entire file into the container’s 8 GB memory, triggering a port alarm and prompting investigation and recommendations to use streaming tools instead of Vim.
This article explains the principles of distributed tracing, the OpenTracing standard, SkyWalking's architecture and sampling strategies, and shares practical company implementations and custom plugins that help locate performance bottlenecks in micro‑service systems.
This guide explains what system context switches are, how to monitor them using vmstat and pidstat, provides a practical stress‑ng example that spikes switches, breaks down kernel thread kworker/u256:29-flush-8:0, and clarifies the difference between voluntary and non‑voluntary switches to help troubleshoot performance issues.
Thread profiling uses threshold‑triggered tasks on business threads to capture stack snapshots, which a dedicated profiler thread sends via high‑performance gRPC to a server that queues them in Kafka, enriches and stores them in ClickHouse, correlates with OpenTelemetry traces, and provides metrics that let developers quickly pinpoint latency bottlenecks and improve system stability.
The article describes how Autohome established a company‑wide, fine‑grained quality measurement system and a comprehensive quality score model that unifies standards across departments, integrates multi‑source data, and drives continuous optimization to enhance user experience and product reliability.
The article walks through diagnosing a 10‑second backend loading delay, explains connection‑pool concepts, introduces Alibaba's Druid pool with its monitoring UI, shows how to identify and optimize slow SQL queries using DISTINCT and indexes, and provides step‑by‑step SpringBoot integration instructions.
This article outlines a systematic approach to ensuring high availability for e‑commerce mega‑promotion events, covering historical context, business model analysis, goal setting, strategic planning, tactical execution, and growth, with detailed evaluation of marketing, transaction, fulfillment, and monitoring processes.
This guide details essential Oracle database daily inspection commands—covering instance status, tablespace health, resource usage, performance metrics, server CPU/memory/I/O checks, and security audits—to help DBAs ensure system stability and quickly diagnose issues.
The mysqlstat command‑line tool provides real‑time monitoring and analysis of MySQL servers, offering metrics such as QPS, TPS, network bandwidth, top‑executed SQL statements, hot tables, lock and deadlock information, index analysis, connection counts, table size statistics, binlog insights, and replication status, with usage examples and download instructions.
This guide explains how to install and configure the open‑source Pyroscope continuous profiler on a Kubernetes cluster, integrate it with Python, .NET, and Go microservices, and visualize low‑overhead flame graphs to identify performance bottlenecks and reduce cloud costs.
This article describes a comprehensive approach to stress‑testing a WebRTC SFU service with 300 concurrent connections, covering client generation via Playwright, monitoring setup, test execution, encountered issues, tuning steps, and final performance conclusions.
This article explains Linux disk I/O performance metrics, benchmark methods, observation tools like iostat, pidstat, and iotop, and walks through a practical case of diagnosing and resolving an I/O spike caused by the jbd2 journaling process.
This guide explains how to use the Arthas monitoring tool to identify and troubleshoot Java thread deadlocks and excessive CPU usage, demonstrating commands like thread -b and thread -n, interpreting output, and analyzing thread dumps to pinpoint problematic code and optimize performance.
This article introduces a comprehensive set of Linux performance and observability tools—such as vmstat, iostat, dstat, iotop, pidstat, top/htop, mpstat, netstat, ps, strace, uptime, lsof, perf, and sar—explaining their purpose, typical usage, and how they fit into basic and advanced performance analysis workflows.
Over the past year, Taobao Live’s video‑quality team, led by former algorithm researcher Xiaocen, built an automated attribution system, real‑time low‑quality detection, and close streamer support, turning pure research into product‑focused engineering that boosted stream quality, trust, and business impact through cross‑domain collaboration.
This article explains performance monitoring concepts, lists essential metrics such as response time and CPU utilization, introduces popular monitoring tools like Prometheus and New Relic, and outlines a step‑by‑step process for selecting, configuring, visualizing, alerting, and continuously improving system performance.
The article explains how to build a frontend performance monitoring system that uses PerformanceObserver and the js‑self‑profiling API to capture Core Web Vitals, detect long‑task jank, correlate network requests and user actions, and preview future ComputePressure metrics for comprehensive user‑experience diagnostics.
This guide explains how to perform CPU stress testing on Linux by installing and using the stress and mpstat commands, detailing installation steps, command options, example executions, and how to interpret their output to assess system performance and stability.
In this detailed case study, HuoLala's stability leader shares how a two‑year, zero‑to‑one stability metric framework was designed, implemented, and iterated—covering the why, the pain points, the metric definition process, data collection platform, cultural adoption, and the resulting 78% fault reduction and SLA improvement from three to four nines.
MyPerf4J is a Java‑agent based, low‑overhead performance monitoring library that provides real‑time method, memory, GC and class metrics for high‑concurrency, low‑latency applications, offering quick start, configurable properties, and detailed statistical reports for both development and production environments.
Tencent Cloud’s extensive PMU enhancements—including guest PEBS support, new Intel SPR PDIR++ and PDist features, and AMD Zen4 PerfMon V2 with global‑control registers—significantly lower KVM virtualization overhead, boost instruction‑level accuracy, and provide upstream open‑source contributions for broader cloud performance optimization.
This tutorial walks through installing Alibaba Arthas, using it to monitor and analyze a Java Fibonacci application, and demonstrates key commands such as dashboard, thread, jad, monitor, watch, and profiler for effective performance debugging without code changes or restarts.
This article explains how to replace invasive manual timing code with a lightweight Java Agent that leverages the java.lang.instrument API, ASM bytecode manipulation, and the Attach API to measure method execution time, perform dynamic class redefinition, and integrate with tools like Arthas for runtime tracing.
This article outlines a comprehensive SQL governance framework that moves defense to the testing stage, introduces SQLReview and new‑SQL detection with fingerprinting, details full‑SQL analysis for deep insight, and explains capacity prediction through simulated traffic load testing in a hybrid‑cloud environment.
MyPerf4J is a Java‑agent based, low‑overhead monitoring solution that provides real‑time method, memory, GC and class metrics, enabling developers to quickly locate performance bottlenecks and assess service capacity in both development and production environments.
This article explains the need for full‑link monitoring in micro‑service architectures, describes its core concepts and components such as spans, traces, and annotations, and compares three popular APM solutions—Zipkin, Pinpoint, and SkyWalking—across performance, scalability, data analysis, and ease of integration.
This article introduces Bistoury, a one‑stop Java application diagnostic solution that improves upon Arthas by adding a web UI, multi‑machine support, integrated agent‑proxy architecture, custom classloaders, online debugging, per‑thread CPU monitoring, and heap object statistics.
This article introduces a collection of essential Linux command‑line tools for stress testing and monitoring system resources such as CPU, memory, disk, network, processes, load, temperature, and other aspects, helping administrators assess stability and performance.
This article shows how a concise 10‑line shell script, created with ChatGPT, can continuously capture MySQL QPS, TPS, and connection counts and append the metrics to a log file for performance monitoring.
This article details JD's end‑to‑end H5 observability solution, covering the challenges of hybrid app development, the design of a three‑stage UEM platform, deep active and passive monitoring, automated quality gates, and real‑world case studies that demonstrate cost savings and performance improvements.
When a Linux server suddenly spikes in load and alerts flood your phone, you can pinpoint the cause within a minute by using ten powerful commands from Netflix's performance engineering team to quickly assess CPU, memory, disk I/O, and network metrics.
This article explains why data governance matters for small‑to‑medium enterprises, outlines its four key values, describes essential governance components, and provides a step‑by‑step framework—including timing, roles, standards, execution mechanisms, tools, and common pitfalls—to help organizations implement effective data governance.
The article explains how to monitor, locate, and remediate Android ANRs by installing a LooperPrinter‑based timeout detector, extending coverage to IdleHandler and touch events, dumping and aggregating main‑thread stacks via Firebase Crashlytics, and showcases real‑world fixes that cut online ANRs by 73.8%.
This article outlines ZuanZuan’s capacity management approach, covering its objectives, development stages, water‑level metrics, resource optimization techniques, cluster capacity assessment, stress‑test indicators and standards, as well as scaling strategies, demonstrating how systematic capacity management reduces costs while ensuring service stability.
This article explains the principles, architecture, and practical implementation of distributed tracing—especially SkyWalking—in microservice environments, showing how it identifies call chains, isolates performance bottlenecks, and integrates with existing monitoring systems while maintaining low overhead and non‑intrusive instrumentation.
This article explains common latency analysis techniques, details the principles and implementation of critical path tracing, and demonstrates its practical application in Baidu App's recommendation service to efficiently identify and reduce performance bottlenecks in complex distributed architectures.
Linux load average, a key performance metric, is computed by periodically aggregating per‑CPU runnable and uninterruptible task counts into a global instantaneous load, then applying an exponential weighted moving average to produce 1‑, 5‑, and 15‑minute averages, which are exposed to user space via the /proc/loadavg pseudo‑file.
The article examines the unique QA and testing challenges of Taobao’s Mini Program game ecosystem—such as incomplete container tools, lacking engine standards, and diverse usage patterns—and proposes solutions including a dedicated testing infrastructure, performance standards, automated integration, proactive monitoring, fault simulation, and future enhancements.
Guotai Junan’s Intelligent Operations Service Platform, powered by AI‑driven AIOps, passed the China Academy of Information and Communications Technology’s excellence assessment for anomaly detection, showcasing advanced data‑driven monitoring, digital‑transformation initiatives, and future plans for fault prediction, self‑healing, and comprehensive operations intelligence.
The article explains how AIOps—AI‑driven IT operations—has become a strategic trend, details Guotai Junan’s award‑winning intelligent operations platform that achieved the top‑level “exception detection” evaluation, and shares interview insights on implementation, challenges, and future directions.
This article explains the concept of distributed tracing, its importance in micro‑service architectures, the OpenTracing standard, and how SkyWalking implements automatic span collection, context propagation, unique trace IDs, sampling strategies, and performance optimizations to provide low‑overhead observability for backend systems.
This article explains why latency analysis is crucial for user experience in large distributed services, reviews common methods such as RPC monitoring, CPU profiling, and distributed tracing, and then dives deep into the principles, implementation, aggregation, storage, and visualization of critical path analysis, showcasing its practical impact in Baidu's App recommendation platform.
This article explains Linux's Pressure Stall Information (PSI) mechanism, its /proc and cgroup interfaces, how to monitor CPU, memory, and I/O pressure, and presents code‑level optimizations to reduce PSI overhead and improve system performance.
This article explains why latency analysis is crucial for modern online services, compares common techniques such as RPC monitoring, CPU profiling, and distributed tracing, and then details the principle, implementation, and real‑world impact of critical‑path analysis in large‑scale distributed systems.
This article explains how ANRCanary attributes Android ANR problems by analyzing thread deadlocks, barrier message leaks, aggregation signatures, and key‑function extraction, providing developers with concrete detection algorithms and practical examples to resolve high‑impact ANRs.
This article introduces eBPF, explains its origins and how it extends BPF for kernel‑level observability, compares it with SystemTap and DTrace, outlines common use cases, details its loading‑compile‑execute workflow, and provides step‑by‑step Python/BCC examples with installation instructions and advanced latency measurement code.
