distributed-tracing

Implement distributed tracing across microservices with Jaeger and Tempo.

Updated Mar 11, 2026
One-click install
npx skills add https://github.com/Industrial/rust-symphony --skill distributed-tracing-industrial
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: distributed-tracing
Source: https://github.com/Industrial/rust-symphony/tree/main/.cursor/skills/distributed-tracing
Command: npx skills add https://github.com/Industrial/rust-symphony --skill distributed-tracing-industrial

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill enables the implementation of distributed tracing across microservices, allowing for the visualization and debugging of request flows and the identification of performance bottlenecks.

Core Features & Use Cases

  • Request Flow Visibility: Track requests as they traverse multiple services.
  • Performance Bottleneck Identification: Pinpoint services or operations causing latency.
  • Error Propagation Analysis: Understand how errors propagate through the system.
  • Use Case: Debugging a slow API response by tracing a request from the frontend through the API gateway, authentication service, and user service to the database.

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 debug latency issues across microservices?

Debug microservice latency issues by implementing distributed tracing with Jaeger or Tempo to visualize request flows and pinpoint slow operations. This approach tracks requests across service boundaries to identify exactly which service causes performance bottlenecks.

What is distributed tracing and when do I need it for performance debugging?

Distributed tracing is a method to monitor request flows across microservices, needed when debugging complex distributed systems. It provides visibility into how requests traverse multiple services, helping analyze error propagation and pinpoint latency issues.

How do I set up OpenTelemetry instrumentation for a Python Flask application?

Set up OpenTelemetry instrumentation in your Python Flask application by configuring the SDK to export trace data to a Jaeger or Tempo backend. This implementation requires proper backend setup to collect and visualize the generated trace data.

Can I use Jaeger and Tempo together for microservice observability?

Jaeger and Tempo are both backends used for storing and querying distributed tracing data collected via OpenTelemetry. You select one based on your observability stack preferences to visualize request flows and analyze error propagation.

Why do I need OpenTelemetry to analyze error propagation in distributed systems?

You need OpenTelemetry to standardize application instrumentation, which generates the trace data required to analyze error propagation. This instrumentation captures spans across microservices, enabling backends like Jaeger to visualize how failures cascade.

What are the limitations of distributed tracing for service dependencies?

Distributed tracing for service dependencies requires proper application instrumentation with OpenTelemetry and backend setup for Jaeger or Tempo. Without complete instrumentation across all microservices, trace visibility breaks and request flow analysis becomes incomplete.