ring:dev-sre

Validate structured JSON logging, OpenTelemetry tracing, and context propagation in code.

4|Updated Jan 10, 2026
One-click install
npx skills add https://github.com/LerianStudio/ring-for-opencode --skill ring-dev-sre
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ring:dev-sre
Source: https://github.com/LerianStudio/ring-for-opencode/tree/main/assets/skill/dev-sre
Command: npx skills add https://github.com/LerianStudio/ring-for-opencode --skill ring-dev-sre

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill verifies that developers have implemented observability in their code by validating structured logging, distributed tracing, and context propagation. It does not implement observability itself; it only validates the presence and correctness of observability artifacts according to Ring standards.

Core Features & Use Cases

  • Structured Logging Validation: Ensures logs are in JSON format with timestamp, level, and trace_id, enabling end-to-end correlation.
  • OpenTelemetry Tracing: Verifies instrumentation of distributed traces across handlers, services, and repositories.
  • Context Propagation: Checks that trace context is propagated through external calls (HTTP/GRPC) and across service boundaries.
  • Gate 2 Validation Workflow: Applies after Gate 0 observability implementation and before Gate 3 testing; can dispatch fixes to the implementation agent and re-validate up to three iterations.

Quick Start

Use the ring:dev-sre skill to validate observability for a given unit by supplying the required inputs such as unit_id, language, service_type, implementation_agent, and the path to implementation_files produced in Gate 0. The skill will report a validation summary, instrumentation coverage, and any issues to resolve before moving to the next gate.

Frequently Asked Questions about ring:dev-sre

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

FAQPage Schema
How do I validate OpenTelemetry tracing and structured logging in my code?

You validate observability by auditing implementations for structured JSON logging, OpenTelemetry tracing, and context propagation. This skill checks that your code meets Ring standards, requiring timestamps, levels, and trace_ids for end-to-end correlation across handlers and services.

Does context propagation validation work for both HTTP and GRPC external calls?

Context propagation validation works for HTTP and GRPC external calls by verifying that trace context is correctly propagated across service boundaries. It ensures distributed traces remain intact when your handlers, services, or repositories interact with external dependencies.

How do I enforce a minimum instrumentation coverage threshold before testing?

You enforce instrumentation coverage by running a validation audit that requires at least 90% instrumentation across your codebase. This gate validation verifies distributed traces are properly applied to handlers, services, and repositories before progressing to the testing phase.

Can I validate observability for Go, TypeScript, and Python service types?

Observability validation supports Go, TypeScript, and Python across service types including API, worker, batch, CLI, and library. It applies Ring standards uniformly to verify structured logging, tracing, and propagation compliance regardless of the language or service architecture.

What happens if my structured logging or tracing validation fails?

When validation fails, the skill dispatches fixes to the implementation agent and re-validates up to three iterations. It reports a validation summary, instrumentation coverage percentage, and specific issues to resolve before moving to the next gate.

When do I need to run observability validation in my development workflow?

You need observability validation after implementing tracing and logging in Gate 0 and before testing in Gate 3. This Gate 2 validation step ensures your structured JSON logs and OpenTelemetry traces meet compliance requirements before progressing downstream.