More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Observability and Instrumentation

    1

    Make production features diagnosable before they page you: on-call questions first, the right signal per question, symptom alerts with runbooks, verified.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Observability and Instrumentation

    Observability and Instrumentation

    Example session with this skill installed

    We are shipping a new checkout API next week — it calls a payment provider and an inventory service, and a nightly job updates prices. Our current observability is application logs in plain text and a CPU dashboard. Give us an instrumentation plan for the launch.

    • Read your context and instructions
    • Compiled the observability and instrumentation

    Questions first, per the protocol: (1) Is checkout failing right now, and for what share of attempts? (2) When it fails, is it us, the payment provider, or the inventory service? (3) Which step eats the latency at p95? (4) Did the price-update job run before the morning peak? Every signal below answers one of these — nothing else got added.

    Metrics (questions 1, 2, 4): RED per endpoint — request rate, error ratio rather than count, duration as a histogram — with labels only from small fixed sets: route template, status class, provider name. A per-dependency error ratio for the payment provider and the inventory service answers question 2 at a glance. A last-success timestamp on the price job answers question 4; absence is the failure mode logs alone cannot show.

    Logs (the "why" for a single order): one structured event per significant step — checkout_started, payment_authorized, payment_failed with fields {order_id, provider, error_code, attempt}, order_completed — with a request ID minted at the edge and stamped on every line, span, and outbound call, plus an entry_point field (web, mobile, retry-worker). Fields are allowlisted; full request bodies and card data never appear.

    Traces (question 3): auto-instrumentation on HTTP and the database, manual spans around the pricing calculation and the provider call, context propagated into the fulfillment queue message so the trace survives the async hop. Sample 5% of successes, keep every error.

    Alerts, symptoms only, two severities: PAGE when the checkout error ratio exceeds 2% for 10 minutes, or the price job's last-success passes 26 hours; TICKET when p99 creeps 30% week over week. Each links a three-line runbook. Dashboard: one page, panels in question order — your CPU graph does not make the cut.

    Verification, the step that makes this done: in staging, force the provider call to fail. The payment_failed event appears with the right fields, the error-ratio alert fires to the on-call channel, and the failed order is traceable by request ID in under two minutes. Readiness score 11 of 12 — metric-to-trace exemplar links are unavailable in your current stack, logged as a dated follow-up. Ship.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    A feature that runs but cannot be diagnosed is not finished — it just has not paged anyone yet. This skill instruments production work the disciplined way: start from the questions on-call will ask at 3am, choose the right signal for each one, and verify the telemetry itself before calling it done.

    The protocol opens with two to four concrete on-call questions per feature ("did last night's run complete, and how long did it take?"). Every log event, metric, and span must answer one of them; a signal that answers no question is noise with a maintenance cost. A decision table maps question shapes to signals — metrics tell you that something is wrong and how widespread, traces tell you where the time went, structured logs tell you why this specific case failed — so the choice stops being habit.

    The craft sections cover structured logging as events rather than prose (stable event names, correlation IDs on everything, entry-point stamps when one sink is fed by a scheduler, a webhook, and a CLI), metrics done right (RED per endpoint and dependency, errors as ratios, duration as histograms, percentiles instead of averages), and the cardinality trap that takes metrics backends down when user IDs or raw URLs become labels. Tracing covers context propagation across async boundaries — the gap where traces die — and sampling that keeps every error while discarding most successes.

    Alerting is symptom-based, never cause-based: page on what users feel, ticket what is drifting, dashboard what is merely interesting, with two severities maximum, a runbook linked to every alert, and each alert fired once in staging before it is trusted. Dashboards are built for the incident, answering the on-call questions in order. The skill closes with a six-criterion readiness score (10-12 ship, under 6 the feature runs but is not operable), an instrumentation plan template you fill in per feature, edge cases for batch jobs, black-box third-party dependencies, and legacy code you cannot modify, and a verification drill: induce a failure in staging and find it by correlation ID using only the telemetry. If you cannot, the telemetry is not done.

    This skill designs and verifies instrumentation; it does not choose or configure an observability vendor, provision dashboards in your stack, or run live incident response — during an outage, use your incident process, and use this skill afterward so the next one is diagnosable. The verification drill needs a staging environment where failures can be induced safely; without one, the readiness score stays provisional. Thresholds in the examples are starting points justified by the scenarios shown; your SLOs and traffic history set the real numbers.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 24 days ago

    Permissions

    No special permissions declared or detected

    Listed24 days ago
    Updated21 days ago

    What's inside

    Frequently Asked Questions

    Volume is not visibility. Prose log lines cannot be filtered by field, carry no correlation ID across services, and cannot answer "how widespread" without an afternoon of grep. The skill converts the important moments into structured events with stable names, keeps metrics for the aggregate questions logs answer badly, and deletes the noise that hides the signal.

    Cause-based alerts fire when nothing is wrong (a deploy spikes CPU briefly) and stay silent during failures nobody predicted (a provider outage that never moves your CPU). The skill alerts on symptoms users feel — error ratio, job not completing — with counts replaced by ratios and durations, so the pager means someone is actually hurt.

    Yes, and it is covered as an edge case with its own pattern: run-completion and duration metrics, step-level failure events, and a last-success timestamp, because a scheduled job's worst failure is not running at all — and silence is invisible in logs alone. The readiness score and verification drill apply unchanged.

    New in DevOps & Cloud