This article explains why distributed tracing is essential for microservice architectures, compares common tracing tools, and provides a step‑by‑step guide to integrate Spring Cloud Sleuth with Zipkin, configure logging, switch transport to RabbitMQ, and persist trace data using MySQL.
This tutorial explains the principles of distributed tracing, why it is needed for microservice architectures, and provides step‑by‑step instructions for adding Spring Cloud Sleuth and Zipkin—including Maven dependencies, configuration, Docker deployment, and Elasticsearch persistence—to a Spring Cloud project.
This article explains how to acquire full‑chain tracing information in Node.js applications by leveraging Async Hooks to build an invoke tree, manage context propagation, perform garbage collection, and attach custom metadata, enabling precise debugging of complex asynchronous call graphs.
As micro‑service architectures grow, tracing every request across thousands of services becomes essential; this article examines the need for full‑link monitoring, outlines core requirements and functional modules, explains Google Dapper’s Span/Trace model, and provides a detailed performance‑focused comparison of Zipkin, SkyWalking, and Pinpoint.
This article analyzes the risks and ten typical problems of online applications, compares open‑source self‑built, hosted, and commercial tracing solutions, and explains which advanced diagnostics and dynamic features are essential for selecting the most suitable distributed tracing product.
The article explains how to implement distributed tracing in a microservice architecture using Spring Cloud Sleuth and Zipkin, covering the concepts of spans and traces, configuration steps, code examples, deployment methods, sampling considerations, and persistence options such as MySQL and Elasticsearch.
This article chronicles the four‑year evolution of Baidu's Fengjing performance‑monitoring platform, detailing its data collection, processing pipelines, successive architectural versions (1.0‑4.0), challenges such as probe intrusion and massive data volume, and the engineering solutions that enabled large‑scale, low‑cost, cloud‑native observability for thousands of Java services.
In this talk, Gal Bashan explains how serverless architectures complicate observability and why metrics, logs, and especially distributed tracing with tools like OpenTelemetry, Jaeger, or commercial platforms are essential for gaining end-to-end visibility, automating instrumentation, and maintaining reliable, business-focused services across cloud providers.
This article dissects Baidu Search's ultra‑large micro‑service architecture, detailing the challenges of maintaining five‑nine‑plus availability, the diverse failure modes, and the step‑by‑step evolution of its observability stack—from early log‑only analysis to the kepler1.0/kepler2.0 tracing, full‑log indexing, custom span‑id generation, and compression techniques that together enable rapid root‑cause diagnosis at massive scale.
This article examines the challenges of monitoring complex micro‑service architectures, outlines the objectives of full‑link tracing, explains the Span/Trace data model, describes core functional modules, and provides a detailed performance and feature comparison of Google Dapper, Zipkin, Pinpoint, and SkyWalking.
This article explains what distributed tracing is, why it is needed alongside logging and metrics for observability, how it works with trace and span IDs, and describes Liulishuo's implementation using OpenTelemetry, W3C Trace Context, and tail‑based sampling to improve backend debugging.
The article provides a comprehensive English overview of SkyWalking UI, detailing its dashboard metrics, topology visualization, trace analysis, performance profiling workflow, and alarm management, illustrating how the tool monitors microservice and cloud‑native environments with metrics such as throughput, latency, Apdex, and JVM statistics.
From its 2016 debut to the present, Baidu’s Fengjing APM system has evolved through four major releases—moving from invasive jar‑based probes to non‑invasive bytecode agents, adding modular hot‑swap plugins, scaling to thousands of containers, handling billions of daily metrics via Kafka, Doris, and SIA TSDB, while solving probe upgrade downtime, data‑ingestion volume, and call‑graph query latency.
With micro‑service architectures generating complex call chains across thousands of servers, this article analyzes full‑link monitoring concepts, outlines essential requirements, details core components like spans and traces, and compares three major APM solutions—Zipkin, Pinpoint, and SkyWalking—evaluating probe impact, scalability, and data analysis capabilities.
This article explains the fundamentals of full‑link (distributed) monitoring, describes its core components such as spans, traces and annotations, outlines typical system architecture, and provides a detailed performance and feature comparison of three popular APM solutions—Zipkin, SkyWalking, and Pinpoint.
The article explains the need for full‑link monitoring in micro‑service architectures, describes the core concepts of tracing such as spans and traces, outlines functional modules of APM systems, and provides a detailed comparison of three popular solutions—Zipkin, Pinpoint, and SkyWalking—covering performance impact, scalability, data analysis, developer transparency, and topology visualization.
The article explains the need for full‑link monitoring in microservice architectures, outlines its functional modules and design goals, details the core data structures of Google Dapper (Span, Trace, Annotation) with code examples, and compares three popular APM tools—Zipkin, Pinpoint and SkyWalking—across performance, scalability, analysis depth, transparency and topology features.
This article examines the challenges of monitoring distributed micro‑service architectures, outlines the requirements for a low‑overhead, non‑intrusive tracing system, describes the core concepts of Google Dapper (Span, Trace, Annotation), and provides a detailed functional and performance comparison of three popular APM tools—Zipkin, SkyWalking, and Pinpoint—covering probe impact, collector scalability, data analysis depth, developer transparency, topology visualization, and overall suitability.
This article explains the principles of distributed tracing, the OpenTracing standard, SkyWalking's architecture and sampling strategies, and shares a company's practical customizations—including forced sampling, fine‑grained group sampling, log4j traceId injection, and self‑developed plugins—to help pinpoint performance issues in microservice environments.
Tracing has evolved from early log and stack‑trace techniques to modern distributed observability standards like OpenTracing and OpenTelemetry, and Tencent’s Cloud Service Watcher (TSW) demonstrates how cloud providers integrate these protocols to simplify microservice monitoring, performance metrics, and root‑cause analysis.
This article examines the challenges of monitoring distributed micro‑service architectures, outlines the requirements for a full‑link tracing system, and provides a detailed comparison of three popular APM solutions—Zipkin, Pinpoint, and SkyWalking—covering performance impact, scalability, data analysis, developer transparency, and topology visualization.
This article explains the evolution from a monolithic architecture to microservices, outlines the new pain points such as fault isolation, performance bottlenecks and scaling inefficiencies, and presents a practical, low‑cost distributed tracing solution with unified frameworks, components, configuration management, data collection, and visualization.
This article explains the background of full‑link monitoring in micro‑service architectures, outlines the key requirements for tracing tools, describes core concepts such as spans, traces and annotations, compares Zipkin, Pinpoint and SkyWalking across performance, scalability, data analysis, transparency and topology features, and provides practical deployment guidance to help you select the most suitable solution.
This article describes how a microservice architecture uses IP‑tag traffic routing to separate dynamic test environments from stable ones, implements RPC and MQ routing, and introduces a custom Zipkin‑based distributed tracing system called Tianwang to improve deployment efficiency, resource utilization, and debugging in large‑scale backend services.
This article examines the challenges of monitoring complex micro‑service architectures, outlines the goals and functional modules of full‑link tracing systems, explains Google Dapper’s core concepts such as Span, Trace and Annotation, and provides a detailed performance, scalability and feature comparison of three popular APM solutions—Zipkin, SkyWalking and Pinpoint.
The stability‑assurance squad built an online load‑testing framework that injects global TraceIds via a Java‑agent, records real‑traffic, routes test writes to shadow databases and caches, enforces automatic stop‑rules, and provides a UI platform, reducing cost, improving capacity insight, and enabling safe fault‑injection drills.
This article explains the importance of service tracing in micro‑service architectures, describes core concepts such as traceId and spanId, outlines a three‑layer tracing system (collection, processing, visualization), and shows how real‑time and offline processing enable rapid fault isolation and system‑wide performance optimization.
The 2017‑initiated vivo distributed tracing system leverages a JavaAgent‑based micro‑kernel architecture, using ByteBuddy for non‑intrusive bytecode instrumentation, a Disruptor lock‑free queue, and Kafka to capture Trace/Span data—including cross‑thread propagation—while employing sampling, degradation, and JVM metrics to ensure 94% adoption stability.
This article explains the principles and practical steps for implementing distributed tracing in microservice architectures using Spring Cloud Sleuth and Zipkin, covering why tracing is needed, core concepts like Span and Trace, Maven integration, Docker deployment, Zipkin UI usage, and performance analysis.
Tencent’s Tianji Ge distributed tracing platform, which combines tracing, metrics and logging for billions of daily records, overcame severe cluster jitter and storage latency by applying tiered Elasticsearch index templates, replica reduction, Transport‑API buffering, pre‑created indices and ILM, cutting write latency from 20 s to 0.32 s, shrinking shards by 70 % and saving 30 % of storage.
This article explains the principles, architecture, and practical adoption of distributed tracing—covering OpenTracing standards, SkyWalking's design, sampling strategies, plugin development, and real‑world company practices—to help engineers pinpoint bottlenecks and improve observability in microservice systems.
This article explains how to design a non‑intrusive distributed tracing system for microservices by assigning global TraceIDs, generating hierarchical SpanIDs, using lightweight agents to propagate identifiers via transport headers, and aggregating data in a collector to visualize complete call graphs and diagnose performance issues.
This article explains the fundamentals of distributed tracing, the OpenTracing standard, and how SkyWalking implements automatic span collection, cross‑process context propagation, unique traceId generation, sampling strategies, performance benchmarks, and real‑world adaptations within a micro‑service environment.
This article explains how to design and implement service‑chain (APM) monitoring and end‑to‑end process monitoring in distributed systems, covering concepts such as spans and traces, TRACE_ID generation, logging practices, visualisation techniques, and a practical expense‑report use case with code examples.
This article, excerpted from Wu Sheng’s "Apache SkyWalking实战", explains SkyWalking’s four‑core component architecture, its protocol‑oriented, modular, and lightweight design principles, and highlights its advantages such as seamless traditional and cloud‑native support, easy maintenance, high performance, and extensibility for secondary development.
This article provides an in‑depth analysis of Java’s ThreadLocal mechanism, covering its weak‑reference key, internal ThreadLocalMap structure, hash algorithm, collision resolution, cleanup strategies, expansion logic, source code walkthroughs, and practical usage scenarios such as trace‑ID propagation in distributed systems.
This article provides a comprehensive introduction to Spring Cloud, explaining how it builds on Spring Boot to simplify distributed system development with components for service discovery, configuration management, messaging, monitoring, security, and compares its approach to Dubbo's RPC framework.
Youzan’s full‑link tracing system combines a multi‑language SDK, Java Agent dynamic attachment, transparent upgrades, asynchronous context propagation, and a Spark‑based data pipeline that indexes traces in Elasticsearch and stores them in HBase, enabling real‑time diagnostics, log correlation, and future container‑level tracing expansion.
This talk walks through Sharding-Proxy’s role within Apache ShardingSphere, detailing its architecture, SQL lifecycle from protocol decoding to routing, rewriting, execution, and result merging, while highlighting core principles, performance bottlenecks, and practical optimization techniques for high‑throughput, low‑latency database proxying.
This article provides a comprehensive overview of microservices, covering its origin, definition, core principles such as small independent services, process isolation, lightweight communication, deployment and management, while discussing advantages, challenges, suitable organizational structures, and key technical components like service discovery, gateways, configuration centers, monitoring, circuit breaking, containers, and orchestration frameworks.
This article explains how to build a Chrome extension that integrates with the Hunter distributed tracing system to automatically capture failing API calls during web testing, visualize request chains, and improve debugging efficiency, including manifest configuration, background and popup scripts, and implementation details.
Learn how to integrate Spring Cloud Sleuth for request tracing, configure Zipkin to collect and visualize logs, and persist trace data to Elasticsearch, with detailed code snippets and step‑by‑step instructions for setting up services, running Zipkin, and analyzing trace information.
This guide surveys the most popular open‑source distributed tracing projects, classifying them by instrumentation, tracer, and analysis capabilities, and explains how they fit into modern microservice observability, helping newcomers understand each tool’s strengths, integrations, and the broader tracing ecosystem.
This article explains why Jaeger is a popular cloud‑native tracing solution, describes its architecture, sampling options, and deployment strategies on Kubernetes—including DaemonSet and Sidecar modes—followed by a step‑by‑step Django integration example and guidance on monitoring, alerting, and resource cleanup.
The article explains why enterprise application monitoring systems are essential, outlines their core components such as Trace, Log, Metric, and Report, discusses distributed tracing techniques, and describes how these insights are designed to aid developers, testers, and operations engineers in performance tuning and fault diagnosis.
Pfinder is a new tool that combines problem finder and performance finder functionalities to help users visualize call relationships and time consumption distributions for efficient problem localization in distributed systems.
This article explains the fundamentals of distributed tracing, covering the original Dapper concepts, the architecture and data model of Zipkin, sampling strategies, storage mechanisms, and how OpenTracing provides a vendor‑neutral API for integrating tracing into microservice systems.
This article explores the fundamentals of distributed tracing, detailing concepts from Google's Dapper paper, the architecture and data model of Zipkin, sampling mechanisms, data propagation, and OpenTracing standards, while providing code examples and practical insights for implementing tracing in microservice environments.
This article explains what APM (Application Performance Management) is, its core concepts, how Java agents collect performance data, the process of integrating APM into distributed systems, and how it helps locate slow interfaces and improve overall application reliability.
With micro‑service architectures causing requests to span dozens of services across multiple teams and data centers, this article explains APM fundamentals, details Google’s Dapper tracing model, and compares three popular APM solutions—Zipkin, Pinpoint, and SkyWalking—highlighting performance impact, scalability, data analysis depth, developer transparency, topology visualization, and community support.
This article explains Application Performance Management (APM), its role in monitoring distributed and micro‑service systems, outlines the five‑dimensional APM model, details core monitoring functions, and reviews leading open‑source APM solutions such as PinPoint, Zipkin, SkyWalking, Prometheus, CAT and Hawkular.
This article explains Pinpoint’s architecture, its plugin system, key data structures like ServiceType and AnnotationKey, and demonstrates how to develop a custom bytecode‑injection plugin for Java applications to achieve low‑overhead distributed tracing.
This guide explains how to install, configure, and use the open‑source Pinpoint APM tool to monitor Java‑based Dubbo applications, covering environment preparation, downloading binaries, modifying configuration files, deploying collector and web components, installing agents, and adding startup parameters for both Tomcat and SpringBoot deployments.
This article introduces the recently open‑sourced SOFA middleware components—including SOFATracer, SOFALookout, SOFA‑Boot, SOFA‑RPC (Node and Java), Eggjs integration, and JarsLink—explaining their features, usage scenarios, and providing GitHub links for developers to adopt these financial‑grade cloud‑native solutions.
An extensive overview of JD.com's microservice component platform explains its underlying architecture, communication technologies, service mesh (ContainerMesh), design tools based on DDD, service evaluation, migration challenges, and the platform's evolution toward a cloud‑native, self‑evolving ecosystem supporting distributed tracing, API gateways, and plugin‑based development.
The article explains the concept, functions, design goals, data models, log collection, and deployment considerations of distributed tracing systems, and compares several open‑source and proprietary solutions such as Dapper, Zipkin, Pinpoint, Alibaba Eagle Eye, and JD Hydra to guide the selection of an appropriate tracing platform.
An in‑depth look at Bilibili’s multi‑layer monitoring overhaul, detailing the shift from a monolithic Zabbix setup to micro‑service‑based ELK, Dapper, Misaka, Traceon and Lancer systems, and how layered observability improves fault detection across business, application, and infrastructure levels.
CallGraph is JD.com's internally developed distributed tracing and service governance platform that addresses the challenges of monitoring complex microservice architectures by providing low‑intrusion, low‑latency tracing, real‑time analytics, configurable sampling, and integration with JMQ, Storm, Spark, HBase, and JimDB for both operational insight and performance optimization.
This article explains Zipkin’s data model, how Spring Cloud Sleuth generates and sends Span and Annotation information, the message‑channel listener that converts Sleuth spans to Zipkin spans, debugging techniques to observe the collected data, and why the number of spans shown in Zipkin’s UI can differ from the raw count.
This guide walks through setting up a Zipkin server, configuring Spring Cloud Sleuth to send trace data via HTTP or RabbitMQ, and using the Zipkin UI to monitor request latency and service dependencies in a Spring Boot microservices environment.
This tutorial explains how Spring Cloud Sleuth creates and propagates Trace‑ID and Span‑ID across microservice calls, shows the required HTTP headers, demonstrates adding the spring‑cloud‑starter‑sleuth dependency, customizing header output, configuring logging levels, and provides runnable code samples with log output for verification.
This article describes the background, design goals, architecture, implementation details, and lessons learned from building a low‑overhead, low‑intrusion distributed tracing system using Kafka, Elasticsearch, and OpenTracing to monitor microservice interactions and support performance analysis and DevOps decision‑making.
To cope with Meituan Hotel’s exploding micro‑service complexity, the infrastructure team built the Satellite System—combining MTrace and a selective, zero‑intrusion Log4j2‑based logging pipeline that streams enriched logs through Kafka, Storm, Redis and Elasticsearch, delivering second‑level trace‑log queries and six‑month retention, dramatically speeding up debugging.
Over seven years, Pinterest’s monitoring team built and refined a three‑pronged observability platform—time‑series metrics, log search, and distributed tracing—scaling from a single‑machine system to handling millions of data points per second across tens of thousands of AWS VMs, while addressing reliability, cost, and usability challenges.
This article chronicles Pinterest's seven‑year evolution from a single‑machine time‑series monitor to a multi‑component system that integrates metrics, log search, and distributed tracing, sharing architectural choices, scaling challenges, and lessons learned for building reliable, high‑performance operations platforms.
This article explains why service monitoring is essential for large‑scale microservice environments, outlines design principles, core monitoring components, dependency mapping, call‑chain analysis, capacity planning, root‑cause analysis, and presents a practical technical architecture for implementing robust monitoring solutions.
QTracer is Qunar’s internal distributed tracing system that generates a global TraceID for each request, records operations across services, and provides features such as execution chain visualization, log correlation, conditional search, service dependency analysis, database statistics, transparent data propagation, and low‑overhead instrumentation for debugging and performance monitoring.
This article provides a comprehensive technical overview of QTracer, Qunar’s internal distributed tracing platform, covering its architecture, core concepts, key features such as execution‑chain queries, log association, conditional searches, data storage, non‑intrusive instrumentation, bytecode injection, and the QTracer Debug tool for online breakpoint debugging.
This article explains how Lianjia designed and implemented LTrace, a zero‑intrusion, high‑performance distributed tracing system that captures full request chains across heterogeneous services, supports multi‑language environments, offers flexible sampling, and enables rapid fault isolation and performance optimization.
Uber’s engineering team chronicles the evolution of its distributed tracing system—from the early Merckx pull‑based solution and TChannel integration to the open‑source Jaeger platform—detailing architectural shifts, sampling strategies, multi‑language client libraries, and the move toward a fully cloud‑native, end‑to‑end observability stack.
This article explains why distributed systems need tracing, outlines design goals, compares major implementations like Zipkin, EagleEye, and Hydra, and details the data collection, storage, and analysis pipelines that enable end‑to‑end visibility and performance optimization in large‑scale services.
CallGraph, JD.com’s in‑house distributed tracing platform, provides low‑intrusion, high‑performance monitoring for micro‑service ecosystems, enabling real‑time call‑graph analysis, TP metrics, flexible configuration, and future extensions such as deep‑learning‑driven insights.
This article surveys the design of end‑to‑end tracing systems for large distributed services, explaining core use cases, tracing approaches, metadata propagation, sampling strategies, visualization techniques, and recommended design choices to improve debugging, performance analysis, and resource attribution.
As microservice architectures grow, service calls become increasingly complex, involving dozens of services and teams, making rapid fault localization and comprehensive data analysis critical; distributed tracing systems address these challenges by providing end‑to‑end visibility, low‑overhead instrumentation, and scalable monitoring across large‑scale applications.
The article introduces MTrace, Meituan‑Dianping’s large‑scale distributed session tracing system, explaining its call‑chain concept, architecture, data‑embedding SDK, trace and span identifiers, APIs for transparent data propagation, and how it enables bottleneck detection, performance optimization, and comprehensive monitoring across heterogeneous backend services.
MTrace, Meituan‑Dianping’s internal distributed tracing platform, assigns a global 64‑bit traceId to each request, instruments RPC, HTTP, database and messaging calls, aggregates data via Kafka into HBase and Hive, and visualizes the full call chain to pinpoint network cross‑datacenter traffic, latency bottlenecks, redundant calls, and correlated exceptions, thereby enabling systematic service‑level optimization.
Twitter’s internal monitoring team built a full‑stack observability platform that handles billions of metric writes per minute, supports distributed tracing, log aggregation, visual dashboards, and alerting across data centers and public clouds, and shares the architecture, components, and key lessons learned.
To support over 140 million monthly active users, Sina Weibo evolved from a simple LAMP stack to a sophisticated third‑generation architecture featuring layered interfaces, service and resource tiers, custom RPC and messaging frameworks, SSD caching, and a large‑scale distributed tracing system called WatchMan.
The article details how Weibo evolved from a LAMP‑based first generation to a third‑generation, orthogonal three‑layer (interface, service, resource) and four‑vertical (business, technology, monitoring, governance) architecture that supports massive high‑availability, high‑concurrency workloads with middleware such as Web V4, MCQ, Motan, object store, SSDCache, and the WatchMan distributed tracing system.
An in‑depth look at Weibo’s evolution to its third‑generation backend system, detailing the orthogonal decomposition model, three‑tier horizontal layering, key middleware such as MCQ, Motan RPC, SSDCache, and the WatchMan tracing platform that together enable high‑availability, massive concurrency, and low‑latency services for billions of users.
In the cloud and mobile era, while many scalability issues can be addressed by cloud platforms, services still face challenges such as remote RPC calls, distributed tracing, configuration management including service discovery and load balancing, and scheduling with lifecycle management, prompting architects to design transparent, pluggable solutions.
