distributed-tracing

Implement distributed tracing for microservices with Jaeger and Tempo.

2|Updated Jan 18, 2026

Search Tags:#microservices #observability #opentelemetry #distributed tracing #jaeger #tempo

Ready to run

npx skills add https://github.com/as4584/antigravity-skills --skill distributed-tracing-as4584

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: distributed-tracing
Source: https://github.com/as4584/antigravity-skills/tree/main/agents-wshobson/plugins/observability-monitoring/skills/distributed-tracing
Command: npx skills add https://github.com/as4584/antigravity-skills --skill distributed-tracing-as4584

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

This Skill provides deep visibility into how requests travel across your microservices, helping you pinpoint performance bottlenecks and understand complex system interactions.

Core Features & Use Cases

End-to-End Request Tracking: Follow a single request as it moves through multiple services.
Performance Bottleneck Identification: Quickly find which service or operation is causing delays.
Observability for Distributed Systems: Essential for debugging and understanding microservice architectures.
Use Case: When users report slow loading times on your e-commerce site, use this Skill to trace a typical user request and identify if the bottleneck is in the product catalog service, the checkout API, or the payment gateway.

Quick Start

Implement distributed tracing in your Python Flask application using OpenTelemetry and Jaeger.

Frequently Asked Questions about distributed-tracing

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I track request flows across microservices to find latency bottlenecks?▼

Distributed tracing tracks request flows across microservices using Jaeger and Tempo to identify latency and failure points. By following a single request as it moves through multiple services, you can pinpoint exactly which operation causes delays.

What is distributed tracing and when do I need it for my microservices architecture?▼

Distributed tracing provides observability for microservice architectures by visualizing how requests travel across services. You need it when debugging complex system interactions or identifying performance bottlenecks in distributed systems where requests span multiple services.

How do I implement distributed tracing in a Python Flask application?▼

You implement distributed tracing in Python Flask applications using OpenTelemetry for application instrumentation and Jaeger as the tracing backend. This setup requires context propagation via HTTP headers to maintain trace continuity across service boundaries.

Do I need OpenTelemetry to use Jaeger and Tempo for request flow visibility?▼

Yes, OpenTelemetry is required for application instrumentation when using Jaeger and Tempo for distributed tracing. It provides the libraries to instrument your code and handles context propagation via HTTP headers across your microservices.

What is the best way to debug slow loading times in an e-commerce microservices setup?▼

Distributed tracing with Jaeger and Tempo visualizes request flows to identify which service causes delays. You can trace a typical user request to determine if the bottleneck is in the product catalog, checkout API, or payment gateway service.

How does context propagation work when tracking requests across multiple services?▼

Context propagation in distributed tracing works by passing trace context via HTTP headers between services. This allows Jaeger and Tempo to stitch together spans from different microservices into a single end-to-end request trace.