home / skills / phrazzld / claude-config / log-observability-issues

log-observability-issues skill

/skills/log-observability-issues

This skill audits observability findings via /check-observability and creates prioritized GitHub issues to track gaps.

npx playbooks add skill phrazzld/claude-config --skill log-observability-issues

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

Files (1)
SKILL.md
2.7 KB
---
name: log-observability-issues
description: |
  Run /check-observability, then create GitHub issues for all findings.
  Issues are created with priority labels and structured format.
  Use /fix-observability instead if you want to fix issues immediately.
effort: medium
---

# /log-observability-issues

Run observability audit and create GitHub issues for all findings.

## What This Does

1. Invoke `/check-observability` to audit monitoring infrastructure
2. Parse findings by priority (P0-P3)
3. Check existing issues to avoid duplicates
4. Create GitHub issues for each finding

**This is an issue-creator.** It creates work items, not fixes. Use `/fix-observability` to fix issues.

## Process

### 1. Run Primitive

Invoke `/check-observability` skill to get structured findings.

### 2. Check Existing Issues

```bash
gh issue list --state open --label "domain/observability" --limit 50
```

### 3. Create Issues

For each finding:

```bash
gh issue create \
  --title "[P0] No error tracking configured" \
  --body "$(cat <<'EOF'
## Problem
No error tracking (Sentry) configured. Production errors are invisible.

## Impact
- Errors happen silently
- Users affected without our knowledge
- No alert when things break
- Debugging requires log diving

## Suggested Fix
Run `/fix-observability` or manually:
```bash
pnpm add @sentry/nextjs
npx @sentry/wizard@latest -i nextjs
```

Configure DSN in environment variables.

---
Created by `/log-observability-issues`
EOF
)" \
  --label "priority/p0,domain/observability,type/chore"
```

### 4. Issue Format

**Title:** `[P{0-3}] Observability gap description`

**Labels:**
- `priority/p0` | `priority/p1` | `priority/p2` | `priority/p3`
- `domain/observability`
- `type/chore`

**Body:**
```markdown
## Problem
What monitoring/logging is missing

## Impact
What goes unseen, risk of blind spots

## Suggested Fix
Commands or skill to run

---
Created by `/log-observability-issues`
```

## Priority Mapping

| Gap | Priority |
|-----|----------|
| No error tracking | P0 |
| No health endpoint | P0 |
| Error tracking misconfigured | P1 |
| No structured logging | P1 |
| Shallow health checks | P1 |
| No alerting | P1 |
| No analytics | P2 |
| Console.log overuse | P2 |
| No uptime monitoring | P2 |
| Performance monitoring | P3 |

## Output

After running:
```
Observability Issues Created:
- P0: 2 (no error tracking, no health endpoint)
- P1: 3 (logging, alerting, deep health)
- P2: 2 (analytics, console cleanup)
- P3: 1 (perf monitoring)

Total: 8 issues created
View: gh issue list --label domain/observability
```

## Related

- `/check-observability` - The primitive (audit only)
- `/fix-observability` - Fix observability gaps
- `/observability` - Full observability setup
- `/groom` - Full backlog grooming

Overview

This skill runs an observability audit and files GitHub issues for every gap the audit finds. It prioritizes findings (P0–P3), avoids duplicate issues, and creates structured issues with suggested fixes and labels. Use this when you want visibility and tracked work items rather than immediate remediation.

How this skill works

The skill invokes /check-observability to get a structured list of findings, groups them by priority, and checks open GitHub issues with the domain/observability label to avoid duplicates. For each new finding it creates a GitHub issue with a standard title, body (Problem, Impact, Suggested Fix) and priority/domain/type labels. It does not apply fixes—use /fix-observability for remediation.

When to use it

  • You need a backlog of observability work created automatically after an audit
  • You want consistent, labeled GitHub issues for monitoring gaps
  • You prefer tracked tasks over automatic remediation
  • You run periodic audits and need to avoid duplicate issues
  • You want clear suggested fixes included in each issue

Best practices

  • Run /check-observability first to produce reliable findings
  • Review generated issues before assigning or scheduling work
  • Keep the Suggested Fix section actionable (commands or /fix-observability link)
  • Limit the gh issue list query to recent open issues to avoid stale duplicates
  • Tweak priority mapping to match your org’s SLAs

Example use cases

  • Post-deployment audit finds missing error tracking; P0 issue created for Sentry setup
  • CI job runs /check-observability on a schedule and files a batch of observability chores
  • Onboarding a new service: run the audit and generate issues to guide engineering work
  • Before a release, run the skill to surface missing alerts and health endpoints
  • Engineering manager exports observability issue list for sprint planning

FAQ

Will this skill fix problems automatically?

No. This skill only creates GitHub issues documenting findings and suggested fixes. Use /fix-observability to apply automated fixes.

How does it avoid duplicate issues?

It queries open issues labeled domain/observability and checks titles before creating new issues to prevent duplicates.