This article walks through adding complete observability to Spring Boot 3 applications using Micrometer's Observation API, covering metrics, tracing, log correlation, configuration, code examples for both server and client, and even native image support for production-ready monitoring.
This article explains how Spring Boot 3.0.0‑RC1 integrates Micrometer Observation to provide unified metrics, logging, and distributed tracing, showing the required dependencies, configuration, code examples for both server and client, and how to visualize data with Prometheus, Grafana, Loki, and Tempo.
This article walks through the evolution of a simple online supermarket from a monolithic website to a fully split microservice architecture, highlighting the challenges encountered—such as code duplication, database bottlenecks, and operational complexity—and presenting practical solutions like service decomposition, monitoring, tracing, gateway control, service discovery, circuit breaking, rate limiting, testing strategies, and the use of service meshes.
Effective monitoring combines comprehensive system and application metrics—using the USE (Utilization, Saturation, Errors) method to pinpoint resource bottlenecks, and leveraging tools like Prometheus, Grafana, and ELK stacks for data collection, storage, querying, alerting, visualization, and full‑stack tracing across distributed services.
This article details the evolution of monitoring technologies, HuoLala's three‑phase monitoring architecture, the integration of Prometheus, VictoriaMetrics and SkyWalking, zero‑intrusion bytecode instrumentation, full‑link trace sampling, visual dashboards, metric‑trace‑log correlation, and future plans for root‑cause analysis and intelligent alerting.
This article details Baidu's comprehensive approach to improving Android app launch performance by evaluating existing tracing tools, selecting Perfetto, developing a Gradle-based automatic instrumentation plugin, handling trace collection and analysis with Trace Processor, and implementing automated detection of regressions, lock contention, and method-level CPU and wall‑time degradations.
This article presents DeepFlow, an open‑source, highly automated observability platform that uses eBPF to provide zero‑code AutoMetrics and AutoTracing, integrates with Prometheus, OpenTelemetry and SkyWalking, and enables SRE, DevOps and NewOps teams to build full‑stack metrics and blind‑spot‑free tracing for cloud‑native applications.
Building probe capabilities on OpenTelemetry gives cloud‑native teams a vendor‑neutral, standardized way to extend monitoring into full observability—supporting large‑scale, language‑specific instrumentation, plug‑and‑play plugins, and seamless integration with APM backends—so developers and operators can detect, debug, and predict faults across distributed containers.
This article details the design, data‑collection pipeline, monitoring stack, visualization practices, and alert‑response workflow of a globally deployed Alibaba Cloud‑native system that uses ACK, Prometheus, Grafana, and ARMS to achieve end‑to‑end observability across metrics, tracing, and logs.
The article explains how NetEase Media rebuilt its core services with Go, created the open‑source ngo framework to unify dependencies, health‑check, tracing, configuration and OpenID support, and provides detailed code examples and integration guidelines for backend developers.
This article walks through the evolution of an online supermarket from a simple monolithic web app to a fully fledged microservice architecture, detailing the motivations, design decisions, component breakdown, common pitfalls, and essential practices such as monitoring, tracing, logging, service discovery, resilience patterns, testing, and the role of service meshes.
This article explains cloud‑native observability, defines its three pillars—metrics, tracing, and logging—details the OpenTelemetry tracing data model and Span structure, reviews industry implementations such as Jaeger and Alibaba Eagle Eye, and shares practical challenges and solutions from real‑world production use.
The article explains that CompletableFuture offers paired asynchronous methods—one using the default ForkJoinPool and another accepting a custom executor—and argues that providing an explicit thread pool avoids shared‑pool contention, loss of tracing information, ThreadLocal leakage, and class‑loader issues in Java backend applications.
This article walks readers through the complete lifecycle of a microservice system—from architectural design and Java Spring Boot implementation to Kubernetes deployment, high‑availability setup, monitoring with Prometheus/Grafana, tracing with Zipkin, and flow‑control with Sentinel—providing practical code snippets and step‑by‑step instructions.
This article explains how developers and operators should prepare a Go‑based service for Kubernetes by implementing health‑check endpoints, graceful shutdown handling, metrics exposure, tracing integration, standardized logging, and operational best practices such as stateless design, high availability, self‑healing, and HTTPS configuration.
This article explains how Spring Cloud automatically wraps container‑managed thread pool beans with tracing proxies to preserve distributed‑trace information, details the ExecutorBeanPostProcessor implementation, shows the relevant code for detecting and instrumenting executors, and notes when manual wrapping is required.
The article explains the rising importance of observability in modern operations, defines its control‑theory roots, breaks it down into metrics, traces and logs, and argues that successful implementation requires three pillars—SRE practices, AIOps algorithms, and deep business‑architecture knowledge—together with well‑designed SLOs and critical‑path mapping.
This article explains how Sohu Smart Media built a high‑performance tracing system for microservices by integrating Zipkin for data collection with StarRocks for storage and analytics, covering architecture, data models, SQL queries, Flink processing, and real‑world results that boost observability and engineering efficiency.
Observability is more than just combining metrics, traces, and logs; successful implementation requires the disciplined SRE methodology, AI‑driven AIOps capabilities, and a deep understanding of business architecture to define critical paths and layered SLOs for real‑world systems.
This article describes how Sohu Intelligent Media built a microservice tracing system using Zipkin for data collection and StarRocks for storage and analysis, covering architecture, data model, ingestion pipeline, SQL analytics, performance monitoring, and future improvements.
This article explains how to build a comprehensive monitoring system for both infrastructure and applications, introducing the USE (Utilization‑Saturation‑Errors) method, key performance metrics, and practical components such as Prometheus, Grafana, full‑link tracing, and the ELK stack to detect and diagnose performance bottlenecks.
RTLA (real‑time Linux analysis tool), developed by Red Hat kernel engineer Daniel Bristot de Oliveira, has been merged into the Linux 5.17 source tree, offering kernel‑level tracing of OS noise and timer latency, command‑line options for high‑priority task delay reporting, and trace output for debugging real‑time performance.
This article explains what an APM system is, explores the three core components—Logs, Traces, and Metrics—and details the design and implementation of the Dog APM platform, covering client data models, automatic instrumentation, server processing pipelines, and storage strategies.
OpenTelemetry unifies tracing, metrics, and logs by merging OpenTracing and OpenCensus into a cross‑language specification, collector, language SDKs, and instrumentation libraries, offering vendor‑agnostic, low‑maintenance telemetry collection that separates data gathering from business logic while requiring external back‑ends for storage and analysis.
This article introduces the third, post‑aggregation approach to link tracing—link analysis—showing how real‑time aggregation of stored trace data can quickly pinpoint uneven traffic, single‑machine failures, slow interfaces, business‑level traffic shifts, and gray‑release anomalies while outlining its practical constraints.
This article explains how Baidu's search middle‑platform adopts cloud‑native observability—covering metrics, distributed tracing, log querying, and topology analysis—to ensure high availability, performance, and controllability for a system handling hundreds of billions of requests across millions of micro‑service instances.
This article explains what an APM system is, compares logs, traces and metrics, reviews popular tools, and then details the design and implementation of the in‑house Dog APM platform—including client data models, Kafka pipelines, processing pipelines, storage in ClickHouse/Cassandra, and UI visualizations.
This article explains how adaptive sampling reduces the performance and storage impact of full‑link tracing by dynamically adjusting the sampling rate based on application QPS, outlines the mathematical model, discusses implementation details such as warm‑up, QPS lag, concurrency, and provides a Java reference sampler.
This article examines Baidu Search's massive micro‑service architecture and reveals the detailed observability, tracing, and metrics techniques—Kepler 1.0, Kepler 2.0, and Prometheus integration—that enable five‑nine‑plus availability, full‑query debugging, and efficient capacity management.
Gaode Ride‑Hailing created a comprehensive 360° observability platform—standardized logging, distributed tracing, multi‑domain metrics, visual dashboards, and an incident workflow—that transforms raw data into actionable insights, accelerates root‑cause analysis, and enables automated fault defense for its large‑scale cloud‑native microservice system.
This article explains the core concepts of observability—metrics, logging, and tracing—how they interrelate, and how to implement them effectively in Kubernetes environments using tools like Prometheus, Grafana, ELK, and distributed tracing solutions.
This article explains the origins and evolution of BPF into eBPF, compares it with classic kernel modules, describes eBPF tracing mechanisms, and shows how eBPF can be leveraged to secure container runtimes against escape and other cloud‑native threats.
OpenTelemetry, a CNCF observability project, standardizes telemetry data models, collection, processing, and export, offering vendor‑agnostic APIs, SDKs, and a configurable collector; the article explains its problem domain, solution components, history, future outlook, and provides a practical Go demo with code and configuration examples.
This article explains how Baidu’s search middle‑platform implements full‑stack observability—metrics, tracing, logs, and topology analysis—to reliably monitor and troubleshoot a system handling billions of requests across hundreds of thousands of microservice instances.
The article outlines a systematic approach to optimizing microservice interface performance by using call‑chain tracing with Kibana, local profiling with DotTrace, and concrete optimization tactics such as batching I/O, improving database queries, caching results, parallelizing calls, and asynchronous processing.
This article walks through the evolution of an online supermarket from a simple monolithic website to a fully split microservice architecture, highlighting the pitfalls of ad‑hoc growth, the need for service abstraction, monitoring, tracing, fault tolerance, testing, and the trade‑offs of frameworks versus service mesh.
This article explains the distinct purposes and characteristics of monitoring, tracing, and logging in system design, compares their typical toolchains such as Prometheus, Jaeger, and ELK, and clarifies when each component is necessary for effective observability.
This article walks through a real‑world production incident involving intermittent interface timeouts, demonstrates how tracing with SkyWalking and log analysis revealed a downstream service problem, explores GC log diagnostics, uncovers misconfigured c3p0 connection‑pool settings, and shares practical lessons for Java backend performance tuning.
This article walks through the transformation of a simple online supermarket from a monolithic design to a fully fledged microservice system, explaining the motivations, architectural changes, component selection, common pitfalls, and best‑practice solutions such as service decomposition, database sharding, monitoring, tracing, service mesh, resilience patterns, and testing strategies.
Modern monitoring has evolved into comprehensive observability, encompassing metrics, logging, tracing, and events, and requires specialized storage solutions for each data type; this article explores the origins, key concepts, and design considerations for building effective observability systems in today's complex internet engineering landscape.
iQiyi’s full‑link automated monitoring platform unifies tracing, metric and log collection with deep offline and real‑time analysis, delivering a DAG‑based call graph, near‑real‑time ingestion of tens of millions of logs, multi‑dimensional alerts and rapid root‑cause diagnosis that cut error‑lookup time by over 50 % and now serves as a core component of the company’s microservice reference architecture.
This article details the design, implementation, and evolution of NetEase Cloud Music's full‑link tracing platform, covering its motivations, architecture, low‑overhead data collection, multi‑dimensional analysis, service grooming, automated diagnosis, and future plans for AI‑driven anomaly detection and big‑data processing.
EMonitor, Meituan’s unified monitoring platform, extends CAT’s concepts with real‑time 10‑second aggregation, richer metric types, advanced dashboards, and seamless integration across IaaS, PaaS, and application layers, illustrating the evolution from log‑based monitoring to a comprehensive, proactive observability system.
The study traced severe Redis latency spikes in an 8‑core container to the Go runtime mistakenly reading the host’s CPU count, which created hundreds of threads and scheduler contention; limiting GOMAXPROCS to the container’s quota eliminated the jitter, while further gains were suggested by reducing HMGET calls, tuning GC, and upgrading Go.
This article compares Meituan’s in‑house EMonitor with the open‑source CAT platform, outlines their core monitoring models, sampling pipelines, custom metrics and integration capabilities, and traces the evolution of monitoring stages from log‑based to intelligent root‑cause analysis.
This article presents a detailed, step‑by‑step illustration of microservice architecture, covering its motivations, component breakdown, migration from monoliths, common pitfalls, monitoring, tracing, logging, gateway, service discovery, resilience patterns, testing strategies, frameworks, and the emerging service‑mesh approach.
This article explains the three main monitoring approaches—log collection, distributed tracing, and metric gathering—in microservice architectures, outlines the layered monitoring model, lists key system, application, and user metrics, and reviews popular open‑source time‑series monitoring tools such as Prometheus, OpenTSDB, and InfluxDB.
This article reviews Ant Financial's cloud‑native observability journey, covering its origins, the three pillars of tracing, metrics and logging, community projects like OpenTelemetry, practical implementations, sampling strategies, and future directions for unified microservice, mesh, and serverless monitoring.
This guide walks you through deploying a Knative Service on Alibaba Cloud Container Service, configuring logging and monitoring with Log Service, setting up alerting, and enabling distributed tracing, providing step‑by‑step commands, YAML examples, and console screenshots for a production‑grade serverless setup.
This article explains how to build a comprehensive monitoring system for distributed applications by classifying monitoring functions, describing data quadrants, outlining core modules such as collection, processing, feature extraction, and visualization, and reviewing typical implementations for metrics, logs, tracing, alerting, and the key open‑source components involved.
The Shanghai Go technology salon brought together senior architects from QuTouTiao, Qiniu, and Bilibili to share real‑world implementations of Service Mesh, full‑link tracing, and microservice governance using Go, highlighting practical challenges, solutions, and future directions.
This article explains why Tubi adopted Node.js’s async_hooks API, describes the challenges of context propagation in asynchronous calls, demonstrates a monkey‑patching solution for HTTP servers, and shares production‑grade practices for tracing, retries, and memory management in their micro‑framework.
This article explains how to describe, publish, register, discover, invoke, monitor, trace, and govern RPC services in a microservice architecture, covering RESTful API, XML configuration, IDL files, registry principles, Zookeeper deployment, connection methods, server processing models, monitoring metrics, tracing concepts, and common governance techniques such as load balancing and fault tolerance.
This article investigates why the Sysinternals Sysmon monitoring tool occasionally consumes an entire CPU core and rapidly increases memory usage, analyzes thread creation, handle explosion, and registry settings, reproduces the issue on any machine, and proposes practical solutions to stop the recursive behavior.
This article presents the challenges of virtual product development and describes three engineering solutions—a Footprint tracking system, a Mock Server platform, and a pre‑release gray‑release strategy—detailing their backgrounds, architectures, implementations, and operational benefits for improving debugging, testing, and deployment efficiency.
Pandora.js, the Alibaba Midway team's first open-source project, consolidates years of production-grade Node.js operations by offering three core capabilities—manageable application and process control, comprehensive metrics, and Open-Tracing-based request tracing—exposed via RESTful APIs and logs for easy integration.
When Git commands produce hard‑to‑diagnose errors, you can activate detailed tracing in PowerShell by setting the environment variables GIT_TRACE and GIT_CURL_VERBOSE to 1, which makes Git output extensive operation details to help locate the problem.
This article explains how to combine Node.js's experimental Async Hooks and Performance Timing APIs to create a simple tracing and performance monitoring tool, eliminating manual timing and offering a foundation that can be extended into a custom solution, while also noting an open‑source Pandora.js utility.
Pinpoint is a full‑stack, non‑intrusive tracing platform that visualizes service topology, active threads, request latency, and application health, and this article explains its architecture, data model, and step‑by‑step process for creating custom plugins—including ServiceLoader configuration, TraceMetadataProvider, and ProfilerPlugin implementations with code examples.
This article explains how to leverage the Linux perf tool to profile Oracle database workloads, covering basic commands, probe-based tracing of Oracle internal functions, generating various flame graphs, and practical Q&A for integrating perf into performance monitoring workflows.
This guide explains how to launch SQL Server 2008 Profiler, describes its key columns such as CPU, Duration, Reads, Writes, and shows how to filter traces by SPID, enabling performance comparison and session-specific monitoring.
