AutoGineer
Generated banner for Distributed Tracing
Generated logo for Distributed Tracing

Distributed Tracing

Seth HobsonCommunityCreated by Seth Hobson

  • Skill
  • Tool integration
  • Cloud and DevOps
  • MIT
  • No issues found
Download ZIP

From the author

Implement distributed tracing with Jaeger and Tempo to track requests across microservices and identify performance bottlenecks. Use when debugging microservices, analyzing request flows, or implementing observability for distributed systems.
— the description by Seth Hobson

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a framework for implementing distributed tracing in microservice architectures. By leveraging Jaeger and Tempo, developers can track end-to-end request journeys, visualize service dependencies, and pinpoint performance bottlenecks. It covers core concepts like traces, spans, and context propagation, alongside practical implementation patterns for Python and Node.js using OpenTelemetry. The guide also includes best practices for sampling, instrumentation, and log correlation to ensure efficient observability with minimal overhead.

What it does

  • Provides patterns for instrumenting microservices with OpenTelemetry.
  • Explains how to deploy Jaeger for trace collection and visualization.
  • Demonstrates how to correlate application logs with trace IDs.
  • Offers best practices for sampling rates and span management.
  • Includes troubleshooting steps for common tracing connectivity and latency issues.
  • Defines standard structures for traces, spans, and metadata tags.

When to use it

  • When debugging latency issues in distributed systems.
  • When you need to visualize service dependencies and request paths.
  • When identifying failure points or error propagation across services.
  • When implementing observability standards for production microservices.

Advantages

  • Enables end-to-end visibility into complex request flows.
  • Helps isolate performance bottlenecks to specific services or database queries.
  • Supports standard instrumentation practices via OpenTelemetry.
  • Provides actionable guidance on balancing observability with system performance.

Usage examples

“How do I instrument my Python Flask application for distributed tracing?”
The skill provides a code example using OpenTelemetry's TracerProvider and JaegerExporter to automatically instrument Flask routes and manual spans.
“What are the best practices for sampling traces in production?”
The skill recommends a 1-10% sampling rate in production and using batch span processors to maintain performance overhead below 1%.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/wshobson/distributed-tracing/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip distributed-tracing.zip -d .agents/skills

Documentation by Seth Hobson

Distributed Tracing

Implement distributed tracing with Jaeger and Tempo for request flow visibility across microservices.

Purpose

Track requests across distributed systems to understand latency, dependencies, and failure points.

When to Use

  • Debug latency issues

  • Understand service dependencies

  • Identify bottlenecks

  • Trace error propagation

  • Analyze request paths

Detailed patterns and worked examples

Detailed pattern documentation lives in references/details.md. Read that file when the navigation tier above is insufficient.

Best Practices

  1. Sample appropriately (1-10% in production)

  2. Add meaningful tags (user_id, request_id)

  3. Propagate context across all service boundaries

  4. Log exceptions in spans

  5. Use consistent naming for operations

  6. Monitor tracing overhead (<1% CPU impact)

  7. Set up alerts for trace errors

  8. Implement distributed context (baggage)

  9. Use span events for important milestones

  10. Document instrumentation standards

Integration with Logging

Correlated Logs
import logging
from opentelemetry import trace

logger = logging.getLogger(__name__)

def process_request():
    span = trace.get_current_span()
    trace_id = span.get_span_context().trace_id

    logger.info(
        "Processing request",
        extra={"trace_id": format(trace_id, '032x')}
    )

Troubleshooting

No traces appearing:

  • Check collector endpoint

  • Verify network connectivity

  • Check sampling configuration

  • Review application logs

High latency overhead:

  • Reduce sampling rate

  • Use batch span processor

  • Check exporter configuration

Related Skills

  • prometheus-configuration - For metrics

  • grafana-dashboards - For visualization

  • slo-implementation - For latency SLOs

Files

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Seth Hobson
Publisher
Seth Hobson (Community)
Source
wshobson/agents · plugins/observability-monitoring/skills/distributed-tracing · commit 4bde316
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Seth Hobson or Seth Hobson.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download distributed-tracing.zip