swarm-observability

Guide Rust async applications through tracing and metrics instrumentation.

4|Updated Feb 15, 2026

Search Tags:#debugging #metrics #rust #tracing #instrumentation #observe #error-context

Ready to run

npx skills add https://github.com/d-o-hub/chaotic_semantic_memory --skill swarm-observability

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: swarm-observability
Source: https://github.com/d-o-hub/chaotic_semantic_memory/tree/main/.agents/skills/swarm-observability
Command: npx skills add https://github.com/d-o-hub/chaotic_semantic_memory --skill swarm-observability

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Tracing, metrics, and error context are essential for understanding and maintaining complex async Rust services. This Skill guides adding instrumentation, managing derive macros for observability, and enriching errors for better debugging and reliability.

Core Features & Use Cases

Tracing instrumentation for async functions using #[instrument] to capture function entry, exit, and contextual data.
Metrics collection and structured error context to improve observability dashboards and incident response.
Guidance on using derive macros (noting their deprecation) and transitioning to direct concept builders for better developer experience.

Quick Start

Add tracing and metrics dependencies to your Cargo.toml, annotate async functions with #[instrument], and extend error types with context to begin observable Rust workflows.

Frequently Asked Questions about swarm-observability

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

FAQPage Schema

How do I add tracing instrumentation to async Rust functions?▼

Add tracing dependencies to your Cargo.toml and annotate async Rust functions with the #[instrument] attribute to automatically capture function entry, exit, and contextual data for diagnostics and performance monitoring.

What is the best way to collect metrics and error context in Rust async applications?▼

Collecting metrics and error context in Rust async applications is best achieved by combining tracing instrumentation with extended error types. This approach enriches errors with contextual data to improve observability dashboards and incident response.

How do I transition from deprecated derive macros to direct concept builders for Rust observability?▼

Transition from deprecated derive macros to direct concept builders to improve your developer experience when setting up Rust observability. This Skill provides structured guidance on managing this migration for better tracing and metrics workflows.

Does Rust tracing work with complex async services for performance monitoring?▼

Yes, Rust tracing works effectively with complex async services for performance monitoring and robust error reporting across components. It provides the structured diagnostics needed to understand and maintain concurrent application behavior.

Why do I need to extend error types with context for Rust debugging?▼

Extending error types with context is needed for Rust debugging to provide robust error reporting and better diagnostic visibility. Enriching errors with contextual data helps pinpoint failures quickly across complex async components.