Agent skill

Rust Error Observability

by hashgraph-online in hashgraph-online/awesome-codex-plugins

A skill your agent uses when adding, changing, debugging, or reviewing Rust service error handling and observability, especially when separating domain errors from HTTP responses, adding…

MITAuto-check passedDevOps & Cloud

Install Rust Error Observability

skills CLI
$ npx skills add hashgraph-online/awesome-codex-plugins --skill rust-error-observability -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install hashgraph-online/awesome-codex-plugins rust-error-observability --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/hashgraph-online/awesome-codex-plugins.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/LVTD-LLC/skills/skills/rust-error-observability .claude/skills/rust-error-observability && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
rust-error-observability
GitHub stars
1.2k
Token cost
~969 tokens
SKILL.md length
375 words
Files
5 (incl. references)
Skills in repo
736
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when adding, changing, debugging, or reviewing Rust service error handling and observability, especially when separating domain errors from HTTP responses, adding…

  • Works in 8 steps: Inventory error flows: handler return… → Classify each error by purpose → Keep domain errors typed. Use thiserror… → …
  • Reviewing Rust service error handling and observability
  • SKILL.md covers Core Workflow, Error Boundary Rules, Tracing Rules and HTTP Response Pattern, plus 1 more section
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Rust Error Observability is an agent skill from hashgraph-online/awesome-codex-plugins. Use when adding, changing, debugging, or reviewing Rust service error handling and observability, especially when separating domain errors from HTTP responses, adding thiserror/anyhow, implementing ResponseError or IntoResponse, adding tracing spans, redacting secrets, or diagnosing async failures.

Its SKILL.md is about 970 tokens, which your agent loads only when the skill is triggered. The skill folder holds 6 other files, including reference files (for example `agents/openai.yaml`, `references/error-boundaries.md` and `references/secrets-and-pii.md`). Compatibility notes: Codex, Claude Code, and other Agent Skills-compatible clients.

It sits in DevOps & Cloud, covering Observability and Error handling. It works with Rust. The repository describes itself as: A curated list of awesome OpenAI Codex / ChatGPT plugins, skills, and resources. The 1 Codex Marketplace. See live plugins at: https://hol.org/plugins/best-codex-plugins. The licence is MIT.

When your agent uses it

  • Reviewing Rust service error handling and observability
  • Especially when separating domain errors from HTTP responses
  • Adding thiserror/anyhow
  • Implementing ResponseError

Example prompts

  • “/rust-error-observability”

Requirements

  • Compatibility (from SKILL.md): Codex, Claude Code, and other Agent Skills-compatible clients.

Workflow steps

8 steps, taken from the first numbered list in SKILL.md.

  1. Inventory error flows: handler return types, service/repository errors,
  2. Classify each error by purpose
  3. Keep domain errors typed. Use thiserror for expected branches that callers
  4. Add context at infrastructure boundaries. Use anyhow or opaque application
  5. Map errors to HTTP responses in one place per framework: ResponseError,
  6. Add structured spans before more log lines. Include stable diagnostic fields,
  7. Ensure errors are logged once. Prefer logging at the outer boundary where
  8. Test both the public response and the diagnostic path when behavior changed.

What it can do on your machine

Read from SKILL.md and the folder at commit 16b4156. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are rust).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Codex, Claude Code, and other Agent Skills-compatible clients.

    From compatibility in the SKILL.md frontmatter.

Context cost

Rust Error Observability loads about 969 tokens when it runs, and up to ~2.4k if it reads all its reference files. Until then it costs about 81 tokens; SKILL.md has 375 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~81
When it runs · the whole SKILL.md, loaded when a task matches
~969
With references · SKILL.md plus every file in references/, read only if the agent opens them
~2.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from hashgraph-online/awesome-codex-plugins at commit 16b4156, republished under its MIT licence (© hashgraph-online). 375 words, ~969 tokens.

Download SKILL.mdSave it as .claude/skills/rust-error-observability/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
rust-error-observability
description
Use when adding, changing, debugging, or reviewing Rust service error handling and observability, especially when separating domain errors from HTTP responses, adding thiserror/anyhow, implementing ResponseError or IntoResponse, adding tracing spans, redacting secrets, or diagnosing async failures.
compatibility
Codex, Claude Code, and other Agent Skills-compatible clients.
license
MIT
metadata.version
0.1.0
metadata.displayName
Rust Error Observability
metadata.category
Rust
metadata.tags
rust,error-handling,observability,tracing,backend

Rust Error Observability

Use this skill to make Rust service failures understandable to operators while keeping user-facing responses safe. Treat error handling and telemetry as one design surface.

Core Workflow

  1. Inventory error flows: handler return types, service/repository errors, worker errors, middleware, logs, and tracing setup.
  2. Classify each error by purpose:
    • Domain or validation outcome.
    • Recoverable control flow.
    • Operator diagnostic.
    • User-facing HTTP response.
  3. Keep domain errors typed. Use thiserror for expected branches that callers should match on.
  4. Add context at infrastructure boundaries. Use anyhow or opaque application errors when callers should not match every dependency failure.
  5. Map errors to HTTP responses in one place per framework: ResponseError, Axum IntoResponse, or a small adapter function.
  6. Add structured spans before more log lines. Include stable diagnostic fields, not raw payloads or secrets.
  7. Ensure errors are logged once. Prefer logging at the outer boundary where request context is available.
  8. Test both the public response and the diagnostic path when behavior changed.

Error Boundary Rules

  • Domain modules return domain errors, not HTTP status codes.
  • Repository modules attach query or operation context, but do not log every error.
  • Handlers convert domain outcomes into response types and let unexpected failures become a consistent 500.
  • Background workers log failed job IDs, attempt counts, and next action.
  • Avoid unwrap, expect, or stringly map_err in service paths unless the invariant is local and the panic message is useful.

Read references/error-boundaries.md when choosing between thiserror, anyhow, opaque errors, and framework response adapters.

Show full SKILL.md (126 more words)Show less

Tracing Rules

  • Instrument request handlers, service methods, outbound clients, database operations, and worker jobs at boundaries.
  • Use #[tracing::instrument(skip(...))] for request bodies, pools, clients, passwords, tokens, and large values.
  • Attach fields like request ID, user ID, tenant ID, job ID, upstream name, and idempotency key when safe.
  • Do not log secrets, cookies, password hashes, bearer tokens, or full PII.

Read references/tracing.md for spans, subscriber setup, and test logging. Read references/secrets-and-pii.md before touching secret-bearing values.

HTTP Response Pattern

Keep response errors stable and intentional:

rust
pub enum SubscribeError {
    Validation(SubscribeValidationError),
    Unexpected(anyhow::Error),
}

impl actix_web::ResponseError for SubscribeError {
    fn status_code(&self) -> actix_web::http::StatusCode {
        match self {
            Self::Validation(_) => actix_web::http::StatusCode::BAD_REQUEST,
            Self::Unexpected(_) => actix_web::http::StatusCode::INTERNAL_SERVER_ERROR,
        }
    }
}

The response body should be safe for users. The trace event should carry the diagnostic context operators need.

Reference Files

  • references/error-boundaries.md: choosing error types and response adapters.
  • references/tracing.md: spans, fields, subscriber setup, and test output.
  • references/secrets-and-pii.md: redaction rules for secrets and sensitive user data.

© hashgraph-online, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 4 other files (references) in plugins/LVTD-LLC/skills/skills/rust-error-observability of hashgraph-online/awesome-codex-plugins.

  • SKILL.md
  • agents/openai.yaml
  • references/error-boundaries.md
  • references/secrets-and-pii.md
  • references/tracing.md

Open the folder on GitHubat commit 16b4156

Compare with similar skills

Rust Error Observability next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Rust Error Observability compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Rust Error Observability this skillhashgraph-online/awesome-codex-plugins1.2k—~969Automated safety check: PassMIT
Logging Observabilitygetsentry/toolkit917—~2.6kAutomated safety check: PassCustom licence
Rust SkillsJMBeresford/retrom2.1k1 repos~9.5kAutomated safety check: PassMIT
Logfire Instrumentationbasicmachines-co/basic-memory4.1k—~2.3kAutomated safety check: PassAGPL-3.0
Crash Instrumentationnexus-labs-automation/mobile-observability116—~744Automated safety check: PassMIT
Nemo Relay Migrate From FlowNVIDIA/NeMo-Relay190—~1.8kAutomated safety check: PassApache-2.0

Similar skills

  • Logging Observability

    getsentry/toolkit

    Official

    Review code for correct logging and error handling patterns.

    917 GitHub stars~2.6k tokensUpdated today
    DevOps & CloudAuto-check passed
  • Rust Skills

    JMBeresford/retrom

    Comprehensive Rust coding guidelines with 265 rules across 26 categories.

    2.1k GitHub starsUsed in 1 repo~9.5k tokens
    DevelopmentAuto-check passed
  • Logfire Instrumentation

    basicmachines-co/basic-memory

    Adds Pydantic Logfire tracing, logging and metrics to Python, JavaScript or TypeScript and Rust projects, with the correct setup order and library extras.

    4.1k GitHub stars~2.3k tokensUpdated today
    DevOps & CloudAuto-check passed
  • Crash Instrumentation

    nexus-labs-automation/mobile-observability

    Set up crash instrumentation with actionable context. An agent skill from nexus-labs-automation/mobile-observability.

    116 GitHub stars~744 tokensUpdated 1 mo ago
    DevOps & CloudAuto-check passed
  • Official

    A skill your agent uses when migrating applications, examples, integrations, documentation, manifests, or repository code from NeMo Flow to NeMo Relay across Python, Rust, Node.js, Go, C FFI, CLI…

    190 GitHub stars~1.8k tokensUpdated today
    DevOps & CloudAuto-check passed
  • Guides log level choices and when to raise a structured Sentry event instead of a plain log line in the Warp Rust codebase, keeping secrets out of logs.

    65k GitHub starsUsed in 1 repo~5.6k tokens
    DevelopmentAuto-check passed

More from hashgraph-online/awesome-codex-plugins

All 736 skills in this repo
  • Anime Reaction Gif

    hashgraph-online/awesome-codex-plugins

    Create original anime-style reaction stickers as looping GIFs and MP4 previews, using generated character pose sheets and timed key poses.

    1.2k GitHub stars~922 tokensUpdated yesterday
    Auto-check passed
  • Calibredb

    hashgraph-online/awesome-codex-plugins

    Manage and query Calibre libraries with the calibredb CLI (local paths or Calibre Content server URLs).

    1.2k GitHub stars~1k tokensUpdated yesterday
    Auto-check passed
  • Rust API Test Harness

    hashgraph-online/awesome-codex-plugins

    A skill your agent uses when adding, changing, testing, or debugging Rust HTTP APIs and services, especially when Codex needs black-box integration tests, random-port app startup, real database test…

    1.2k GitHub stars~1.7k tokensUpdated yesterday
    Auto-check passed
  • Art

    hashgraph-online/awesome-codex-plugins

    Make a studio's game look like something at build time — a cover from a real frame of the game (free), painted covers, backdrops, textures and character plates from image models through the…

    1.2k GitHub stars~2.4k tokensUpdated yesterday
    Auto-check passed
  • Calle

    hashgraph-online/awesome-codex-plugins

    Use CALL-E from Codex through the calle CLI. An agent skill from hashgraph-online/awesome-codex-plugins.

    1.2k GitHub stars~2.9k tokensUpdated yesterday
    Auto-check passed
  • Game Balance Economy

    hashgraph-online/awesome-codex-plugins

    Balance game difficulty, resources, rewards, probability, progression, economies, and dominant strategies.

    1.2k GitHub stars~618 tokensUpdated yesterday
    Auto-check passed

Works with

Categories

Questions about Rust Error Observability

What does Rust Error Observability do?

A skill your agent uses when adding, changing, debugging, or reviewing Rust service error handling and observability, especially when separating domain errors from HTTP responses, adding…. Rust Error Observability is an agent skill from hashgraph-online/awesome-codex-plugins. Use when adding, changing, debugging, or reviewing Rust service error handling and observability, especially when separating domain errors from HTTP responses, adding thiserror/anyhow, implementing ResponseError or IntoResponse, adding tracing spans, redacting secrets, or diagnosing async failures.

When should I use Rust Error Observability?

Rust Error Observability fits situations like: reviewing Rust service error handling and observability; especially when separating domain errors from HTTP responses; adding thiserror/anyhow; implementing ResponseError.

How do I install Rust Error Observability in Claude Code?

Run `npx skills add hashgraph-online/awesome-codex-plugins --skill rust-error-observability -a claude-code`. Or copy the skill folder (plugins/LVTD-LLC/skills/skills/rust-error-observability in hashgraph-online/awesome-codex-plugins) into .claude/skills/rust-error-observability in your project. Claude Code loads it when a task matches its description.

How do I install Rust Error Observability in Codex?

Run `npx skills add hashgraph-online/awesome-codex-plugins --skill rust-error-observability -a codex`. Or copy the skill folder (plugins/LVTD-LLC/skills/skills/rust-error-observability in hashgraph-online/awesome-codex-plugins) into .agents/skills/rust-error-observability in your project. Codex loads it when a task matches its description.

Can I use Rust Error Observability in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add hashgraph-online/awesome-codex-plugins --skill rust-error-observability -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/rust-error-observability, .gemini/skills/rust-error-observability, .github/skills/rust-error-observability and .opencode/skills/rust-error-observability in your project.

What does Rust Error Observability need to run?

SKILL.md names no scripts, command-line tools or credentials: Rust Error Observability is instructions for the agent only. Compatibility (from SKILL.md): Codex, Claude Code, and other Agent Skills-compatible clients..

Does Rust Error Observability access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Rust Error Observability safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Rust Error Observability use?

Rust Error Observability is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Rust Error Observability use?

About 969 tokens (SKILL.md is roughly 3.9k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.4k tokens, read only when the agent opens those files.

What are the alternatives to Rust Error Observability?

Skills that share tags, products or a category with Rust Error Observability: Logging Observability (getsentry/toolkit, 917 stars), Rust Skills (JMBeresford/retrom, 2.1k stars), Logfire Instrumentation (basicmachines-co/basic-memory, 4.1k stars) and Crash Instrumentation (nexus-labs-automation/mobile-observability, 116 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Rust Error Observability?

hashgraph-online (a GitHub organization) maintains it in hashgraph-online/awesome-codex-plugins, which has 1,232 GitHub stars. The repository holds 736 skills in this directory. The repository was last updated on October 6, 2026.

Source: hashgraph-online/awesome-codex-plugins on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.