logging-observability

Guide structured logging, OpenTelemetry tracing, and Prometheus metrics implementation.

10|5|Updated Jan 29, 2026
One-click install
npx skills add https://github.com/Claude-Code-Community-Ireland/claude-code-resources --skill logging-observability-claude-code-community-ireland
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: logging-observability
Source: https://github.com/Claude-Code-Community-Ireland/claude-code-resources/tree/main/plugins/vibeworks-library/skills/logging-observability
Command: npx skills add https://github.com/Claude-Code-Community-Ireland/claude-code-resources --skill logging-observability-claude-code-community-ireland

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides comprehensive guidance and best practices for implementing effective logging, tracing, and metrics, enabling developers to build more observable, debuggable, and reliable software systems.

Core Features & Use Cases

  • Structured Logging: Enforces JSON format, defines essential and recommended fields for machine-parseable logs.
  • Log Levels: Details the appropriate usage of ERROR, WARN, INFO, DEBUG, and TRACE levels.
  • Correlation IDs: Explains how to generate and propagate correlation IDs for tracing requests across services.
  • Distributed Tracing: Introduces OpenTelemetry concepts and provides examples for custom span creation.
  • Metrics: Covers Counter, Gauge, and Histogram types with Prometheus client examples.
  • Alerting: Outlines principles for actionable and non-noisy alerts with a YAML template.
  • Health Checks: Details standard /health, /ready, and /live endpoints.
  • Log Aggregation: Compares popular platforms like ELK, Datadog, CloudWatch, and Loki.
  • Observability Checklist: A comprehensive checklist to ensure all aspects of observability are covered.

Quick Start

Implement structured JSON logging with correlation IDs and use the provided checklist to ensure your service is observable.

Frequently Asked Questions about logging-observability

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

FAQPage Schema
How do I implement structured logging for machine-parseable logs?

Structured logging uses JSON format with essential and recommended fields to make logs machine-parseable. This Skill defines the required fields and provides best practices for structuring log data so that aggregation platforms like ELK or Datadog can index and search efficiently.

What's the best way to trace requests across microservices using correlation IDs?

Tracing requests across microservices requires generating and propagating correlation IDs through service calls. This Skill explains how to attach correlation IDs to logs and pairs them with OpenTelemetry distributed tracing to provide full visibility into request flows across distributed systems.

How do I collect custom metrics with Prometheus client libraries?

Prometheus client libraries collect custom metrics using Counter, Gauge, and Histogram types. This Skill provides implementation examples for each metric type, showing how to instrument application code to expose metrics endpoints for scraping and aggregation.

How do I design alerts that are actionable and avoid noise?

Actionable alerting requires clear principles for when to trigger notifications and includes a YAML template for defining alert rules. This Skill outlines alert design principles to ensure alerts are meaningful, non-noisy, and directly linked to system health indicators.

What's the difference between health check endpoints like /health, /ready, and /live?

Health check endpoints distinguish between service availability and readiness: /health provides general status, /ready indicates if the service can accept traffic, and /live shows if the process is running. This Skill details when to use each endpoint for robust orchestration.

How do I ensure my system has comprehensive observability coverage?

Comprehensive observability coverage requires checking structured logging, tracing, metrics, alerting, and health endpoints. This Skill provides a detailed observability checklist to verify all system components are monitored and debuggable across the stack.