skills.rest
ngxtm
ngxtmCOMMUNITY
Explore all skills by this author →
GitHub

Tracing Observability

Enables Rust apps to implement structured logging and distributed tracing with the tracing ecosystem.

Updated Jan 22, 2026
Search Tags:#performance#debugging#logging#observability#rust#tracing
One-click install
npx skills add https://github.com/ngxtm/skill-rule --skill tracing-observability
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: Tracing Observability
Source: https://github.com/ngxtm/skill-rule/tree/main/rules/rust/tracing
Command: npx skills add https://github.com/ngxtm/skill-rule --skill tracing-observability

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps developers implement robust logging and distributed tracing in their Rust applications, making it easier to monitor, debug, and understand application behavior.

Core Features & Use Cases

  • Structured Logging: Implement detailed, field-based logging for better context.
  • Distributed Tracing: Track requests and operations across different parts of your application.
  • #[instrument] Macro: Automatically generate spans and log function calls with minimal boilerplate.
  • Use Case: Debugging a slow API endpoint by tracing its execution path, identifying bottlenecks, and examining logs at each step.

Quick Start

Implement structured logging in your Rust application using the tracing crate.

Frequently Asked Questions about Tracing Observability

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

FAQPage Schema
How do I implement structured logging in my Rust application?▼

Structured logging in Rust is implemented using the tracing ecosystem to record detailed, field-based events. This allows you to capture rich context for better debugging and performance monitoring.

How does distributed tracing track requests across a Rust application?▼

Distributed tracing tracks requests by propagating span context across different parts of your Rust application. This mechanism helps you follow execution paths to pinpoint bottlenecks and errors.

Can I automatically generate spans for Rust functions without boilerplate?▼

Yes, you can automatically generate spans for Rust functions using the #[instrument] macro. This automatically logs function calls and creates spans with minimal boilerplate code.

Does Rust tracing work with OpenTelemetry for observability?▼

Rust tracing supports integration with OpenTelemetry for enhanced observability. You can configure custom subscribers to export structured logs and traces to compatible backends.

What is the best way to debug a slow API endpoint in Rust?▼

The best way to debug a slow Rust API endpoint is by tracing its execution path to identify bottlenecks. You can examine structured logs at each step to understand performance issues.

Related Skills

Explore More Software Engineering Skills→
iamcapoteiamcapote

setup-stellar-contracts

Automate Stellar Soroban contract setup with Rust toolchains and OpenZeppelin crates.

Community
Advanced
briannadoubtbriannadoubt

observability

Configure structured logs, metrics, and traces for Trebuchet actors with CloudWatch export.

Community
Intermediate
wojonswojons
4

distributed-tracing-logs

Implement distributed tracing with log-based trace context propagation and OpenTelemetry integration.

Community
Advanced
Likas07Likas07

logging-best-practices

Guide developers in implementing structured wide events for application logging.

Community
Intermediate