distributed_tracing

Implements distributed tracing for microservices with Jaeger and Tempo.

Updated Dec 23, 2025
One-click install
npx skills add https://github.com/drgaciw/academic-compliance-hub-glm --skill distributed-tracing-drgaciw
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: distributed_tracing
Source: https://github.com/drgaciw/academic-compliance-hub-glm/tree/main/agents/plugins/observability-monitoring/skills/distributed-tracing
Command: npx skills add https://github.com/drgaciw/academic-compliance-hub-glm --skill distributed-tracing-drgaciw

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill provides deep visibility into request flows across distributed systems, enabling rapid identification of performance bottlenecks and failure points.

Core Features & Use Cases

  • End-to-End Request Tracking: Follow a single request as it traverses multiple microservices.
  • Performance Bottleneck Identification: Pinpoint services or operations causing latency.
  • Error Propagation Analysis: Understand how errors cascade through your system.
  • Use Case: When users report slow response times on the main dashboard, use this Skill to trace a typical request, identify which downstream service is lagging, and analyze its internal operations to find the root cause.

Quick Start

Use the distributed tracing skill to instrument the 'user-service' with OpenTelemetry and send traces to 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 a request across microservices to find performance bottlenecks?

Distributed tracing tracks a single request across microservices to pinpoint performance bottlenecks. By instrumenting your application with OpenTelemetry, you can send traces to Jaeger or Tempo to analyze request paths and identify lagging downstream services.

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

Distributed tracing is a method for monitoring microservices that provides end-to-end request visibility. You need it when users report slow response times and you must understand service dependencies or trace error propagation across your distributed system.

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

Yes, OpenTelemetry is required for application instrumentation and context propagation via HTTP headers. This setup allows Jaeger and Tempo to receive the traces and provide the deep visibility needed for analyzing request flows across microservices.

How does error propagation analysis work across a distributed system?

Error propagation analysis works by tracing a request as it traverses multiple microservices, allowing you to see exactly how errors cascade. This helps you understand failure points within your system and identify the root cause of downstream issues.

What is the best way to debug microservices when users report slow response times?

The best way to debug slow microservices is to use distributed tracing to trace a typical request, identify which downstream service is lagging, and analyze its internal operations. This Skill uses Jaeger and Tempo to pinpoint the exact operations causing latency.

Can I use this distributed tracing approach to understand service dependencies?

Yes, you can use this distributed tracing approach to understand service dependencies. By following a single request as it traverses multiple microservices, the traces reveal the underlying architecture and how different services interact during request processing.