distributed-tracing

Implement distributed tracing for microservices with Jaeger and Tempo.

6|2|Updated Oct 19, 2025
One-click install
npx skills add https://github.com/amurata/cc-tools --skill distributed-tracing-amurata
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: distributed-tracing
Source: https://github.com/amurata/cc-tools/tree/main/plugins/observability-monitoring/skills/distributed-tracing
Command: npx skills add https://github.com/amurata/cc-tools --skill distributed-tracing-amurata

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 request flows across distributed systems, enabling developers to pinpoint performance bottlenecks and understand complex service interactions.

Core Features & Use Cases

  • End-to-End Request Tracking: Follow a single request as it traverses multiple microservices.
  • Performance Bottleneck Identification: Quickly identify which service or operation is causing latency.
  • Error Propagation Analysis: Understand how and where errors manifest across your distributed architecture.
  • Use Case: When a user reports slow loading times on your e-commerce site, use this Skill to trace their request from the frontend through the API gateway, product service, and payment service to find the exact point of delay.

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 trace requests across microservices to find performance bottlenecks?

Distributed tracing tracks requests across microservices using OpenTelemetry instrumentation, enabling you to pinpoint exact service operations causing latency. It supports context propagation via HTTP headers to follow end-to-end request flows.

How do I instrument a Python Flask application with OpenTelemetry for Jaeger?

You instrument Python Flask applications with OpenTelemetry by configuring exporters to send trace data to Jaeger. This involves adding tracing middleware and injecting context propagation headers to track requests across service boundaries.

Does distributed tracing work with Node.js and Go microservices?

Yes, distributed tracing supports application instrumentation with OpenTelemetry in Python, Node.js, and Go. All three languages can propagate trace context via HTTP headers and export data to Jaeger or Tempo backends.

What's the difference between using Jaeger and Tempo for trace storage?

Jaeger and Tempo are both supported backends for storing and querying distributed traces. The Skill provides setup instructions for both, allowing you to choose your preferred storage backend while using OpenTelemetry for instrumentation.

Why do I need sampling strategies for distributed tracing?

Sampling strategies control which requests get traced to manage storage overhead and performance impact in high-traffic microservices. The Skill details sampling configuration to balance observability with resource costs.

How does context propagation work across HTTP service boundaries?

Context propagation passes trace identifiers via HTTP headers between microservices, maintaining the parent-child span relationship across service calls. This allows Jaeger and Tempo to reconstruct the complete end-to-end request flow.