observability-tracing

Instrument distributed service calls and diagnose latency and failures across trace paths.

7|Updated Feb 14, 2026
One-click install
npx skills add https://github.com/KentoShimizu/sw-agent-skills --skill observability-tracing
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: observability-tracing
Source: https://github.com/KentoShimizu/sw-agent-skills/tree/main/skills/observability-tracing
Command: npx skills add https://github.com/KentoShimizu/sw-agent-skills --skill observability-tracing

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Observability tracing workflow for distributed trace coverage and critical-path diagnosis. Use when cross-service request paths need instrumentation or analysis to localize latency/error bottlenecks; do not use for business-feature implementation logic.

Core Features & Use Cases

  • Instrument cross-service request paths to collect and map end-to-end traces.
  • Diagnose latency and error bottlenecks by analyzing span propagation and sampling decisions.
  • Use Case: Teams can pinpoint which service in a call chain introduces latency spikes and isolate failures across distributed flows.

Quick Start

Instrument cross-service flows and generate a trace coverage map for critical paths.

Frequently Asked Questions about observability-tracing

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

FAQPage Schema
How do I instrument distributed tracing to find cross-service latency bottlenecks?

Instrument distributed tracing by mapping cross-service request paths and analyzing span propagation to localize latency spikes and isolate failures across microservice architectures. This generates a trace coverage map for your critical paths to pinpoint the exact service introducing delays.

What is trace propagation and how does it work for async boundaries?

Trace propagation passes tracing context across distributed service calls to maintain end-to-end traceability across async boundaries and event-driven flows. This mechanism ensures consistent span attributes and sampling policies are applied throughout the entire cross-service request path.

How do I diagnose latency and error failures across microservice call chains?

Diagnose latency and errors by analyzing span attributes and trace propagation rules across distributed service calls. This approach traces the cross-service request path to identify which specific service in the microservice call chain introduces the failure or performance bottleneck.

Does distributed tracing work for event-driven flows and async boundaries?

Distributed tracing works for event-driven flows and async boundaries by applying trace propagation rules and span attributes across these distributed service calls. This enables consistent queryability and end-to-end traceability for cross-service request paths outside traditional synchronous request-response cycles.

When should I not use observability tracing?

You should not use observability tracing for business-feature implementation logic. This approach is specifically designed for instrumenting cross-service request paths and diagnosing latency bottlenecks across distributed systems, rather than handling application business rules or feature development workflows.

What's the best way to configure sampling policies for distributed systems tracing?

Configure sampling policies for distributed systems tracing by applying consistent rules across span attributes and cross-service request paths. This ensures trace coverage maps maintain queryability for incident debugging while balancing the volume of telemetry data collected from your microservice architectures.