playbooks

home / skills / williamzujkowski / standards / monitoring

monitoring skill

/skills/devops/monitoring

This skill helps you implement robust monitoring standards for devops, emphasizing observability, secure defaults, and maintainable, tested configurations.

npx playbooks add skill williamzujkowski/standards --skill monitoring

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
1.9 KB
---
name: monitoring
description: Monitoring standards for monitoring in Devops environments. Covers best
---

# Monitoring

> **Quick Navigation:**
> Level 1: [Quick Start](#level-1-quick-start) (5 min) → Level 2: [Implementation](#level-2-implementation) (30 min) → Level 3: [Mastery](#level-3-mastery-resources) (Extended)

---

## Level 1: Quick Start

### Core Principles

1. **Best Practices**: Follow industry-standard patterns for devops
2. **Security First**: Implement secure defaults and validate all inputs
3. **Maintainability**: Write clean, documented, testable code
4. **Performance**: Optimize for common use cases

### Essential Checklist

- [ ] Follow established patterns for devops
- [ ] Implement proper error handling
- [ ] Add comprehensive logging
- [ ] Write unit and integration tests
- [ ] Document public interfaces

### Quick Links to Level 2

- [Core Concepts](#core-concepts)
- [Implementation Patterns](#implementation-patterns)
- [Common Pitfalls](#common-pitfalls)

---

## Level 2: Implementation

### Core Concepts

This skill covers essential practices for devops.

**Key areas include:**

- Architecture patterns
- Implementation best practices
- Testing strategies
- Performance optimization

### Implementation Patterns

Apply these patterns when working with devops:

1. **Pattern Selection**: Choose appropriate patterns for your use case
2. **Error Handling**: Implement comprehensive error recovery
3. **Monitoring**: Add observability hooks for production

### Common Pitfalls

Avoid these common mistakes:

- Skipping validation of inputs
- Ignoring edge cases
- Missing test coverage
- Poor documentation

---

## Level 3: Mastery Resources

### Reference Materials

- [Related Standards](../../docs/standards/)
- [Best Practices Guide](../../docs/guides/)

### Templates

See the `templates/` directory for starter configurations.

### External Resources

Consult official documentation and community best practices for devops.

Overview

This skill provides clear monitoring standards for DevOps environments, focused on observability, reliability, and maintainability. It packages quick-start checklists, implementation patterns, and advanced resources so teams can add production-grade monitoring fast. The guidance is concise and oriented to real production systems and common pitfalls.

How this skill works

The skill inspects your monitoring posture and prescribes concrete patterns: architecture choices, observability hooks, error handling, and testing strategies. It highlights required signals (logs, metrics, traces), recommended instrumentation points, and validation steps to ensure secure and reliable monitoring. It also points to templates and reference materials for implementation and scaling.

When to use it

  • Starting a new service and defining its observability plan
  • Onboarding monitoring for existing applications lacking coverage
  • Preparing systems for production releases or SRE handoffs
  • Auditing monitoring maturity during incident retrospectives
  • Scaling observability when adding new components or integrations

Best practices

  • Instrument logs, metrics, and traces with consistent naming and structure
  • Implement secure defaults and validate monitoring input paths
  • Add comprehensive error handling and alerting for actionable signals
  • Write unit and integration tests for monitoring hooks and exporters
  • Document public monitoring interfaces and runbooks for common alerts

Example use cases

  • Create a quick-start checklist to ensure required metrics, traces, and logs are emitted before deployment
  • Standardize error handling and observability across microservices to reduce alert noise
  • Use provided templates to add Prometheus metrics and structured logging to a new Python service
  • Run a monitoring audit to find gaps in test coverage and instrumentation
  • Implement alert routing and runbooks for critical SLO breaches

FAQ

What core signals should I collect?

Collect structured logs, application and system metrics, and distributed traces as a minimum to cover debugging, performance, and request flows.

How do I avoid alert fatigue?

Tune thresholds for meaningful events, group related symptoms, add debounce or suppression rules, and ensure alerts map to documented runbooks.

Are there templates to start from?

Yes, starter templates cover common configurations for metrics, logging, and trace instrumentation to accelerate safe, consistent rollout.