Golang Observability

What it does

When your agent uses it

• Tasks that involve Observability
• Tasks that involve Monitoring and alerting

Example prompts

• “/golang-observability”

Requirements

• Compatibility (from SKILL.md): Designed for Claude Code, Codex or similar harness, and for projects using Golang.
• Pre-approved tools (allowed-tools): Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Agent, WebFetch, WebSearch, AskUserQuestion

Workflow steps

12 steps, taken from the first numbered list in SKILL.md.

1. 1Use structured logging with log/slog — production services MUST emit structured logs (JSON), not freeform strings
2. 2Choose the right log level — Debug for development, Info for normal operations, Warn for degraded states, Error for failures requiring…
3. 3Log with context — use slog.InfoContext(ctx, ...) to correlate logs with traces
4. 4Prefer Histogram over Summary for latency metrics — Histograms support server-side aggregation and percentile queries. Every HTTP endpoint…
5. 5Keep label cardinality low in Prometheus — NEVER use unbounded values (user IDs, full URLs) as label values
6. 6Track percentiles (P50, P90, P99, P99.9) using Histograms + histogram_quantile() in PromQL
7. 7Set up OpenTelemetry tracing on new projects — configure the TracerProvider early, then add spans everywhere
8. 8Add spans to every meaningful operation — service methods, DB queries, external API calls, message queue operations
9. 9Propagate context everywhere — context is the vehicle that carries trace_id, span_id, and deadlines across service boundaries
10. 10Enable profiling via environment variables — toggle pprof and continuous profiling on/off without redeploying
11. 11Correlate signals — inject trace_id into logs, use exemplars to link metrics to traces
12. 12A feature is not done until it is observable — declare metrics, add proper logging, create spans

What it can do on your machine

Read from SKILL.md and the folder at commit 8876467. It shows what the files ask for, not the result of running them.

• Tool permissions

  Pre-approves these tools, so the agent can use them without asking each time:

  • Read
  • Edit
  • Write
  • Glob
  • Grep
  • Bash(go:*)
  • Bash(golangci-lint:*)
  • Bash(git:*)
  • Agent
  • WebFetch

  …and 2 more on the same allowed-tools line.

  From allowed-tools in the SKILL.md frontmatter.

• Runs code

  No scripts in the folder and no shell commands in SKILL.md (its code samples are go).

  From the folder's file list and the shell code blocks in SKILL.md.

• Network

  Links to these hosts (documentation or services it may open):

  • samber.github.io
  • github.com

  From URLs in SKILL.md, links to its own repository left out.

• Credentials

  Names no API keys, tokens, secrets or passwords.

  From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

• Compatibility

  Designed for Claude Code, Codex or similar harness, and for projects using Golang.

  From compatibility in the SKILL.md frontmatter.

Context cost

Golang Observability loads about 3.3k tokens when it runs, and up to ~19k if it reads all its reference files. Until then it costs about 78 tokens; SKILL.md has 1,251 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it

~78

When it runs · the whole SKILL.md, loaded when a task matches

~3.3k

With references · SKILL.md plus every file in references/, read only if the agent opens them

~19k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from context-labs/whip at commit 8876467, republished under its MIT licence (© context-labs). 1,251 words, ~3,337 tokens.

name

golang-observability

description

Go observability — always-on production signals: slog logging, Prometheus metrics, OpenTelemetry tracing, pprof profiling, alerting, Grafana. Apply when instrumenting Go services or migrating zap/logrus/zerolog to slog. Not for performance deep-dives (→ golang-benchmark, golang-performance).

allowed-tools

Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Agent, WebFetch, WebSearch, AskUserQuestion

compatibility

Designed for Claude Code, Codex or similar harness, and for projects using Golang.

user-invocable

true

license

MIT

metadata.author

samber

metadata.version

1.3.0

paths

**/*.go

logger := slog.New(slog.NewMultiHandler(
    slog.NewJSONHandler(os.Stdout, nil),
    auditHandler,
))

import "go.opentelemetry.io/contrib/bridges/otelslog"

// Create a logger that automatically injects trace_id and span_id
logger := otelslog.NewHandler("my-service")
slog.SetDefault(slog.New(logger))

// Now every slog call with context includes trace correlation
slog.InfoContext(ctx, "order created", "order_id", orderID)
// Output includes: {"trace_id":"abc123", "span_id":"def456", "msg":"order created", ...}

// When recording a histogram observation, attach the trace_id as an exemplar
// so you can jump from a P99 spike directly to the offending trace
obs := histogram.WithLabelValues("POST", "/orders")
if eo, ok := obs.(prometheus.ExemplarObserver); ok {
    eo.ObserveWithExemplar(duration, prometheus.Labels{"trace_id": traceID})
} else {
    obs.Observe(duration)
}

// ✗ Bad — log AND return (error gets logged multiple times up the chain)
if err != nil {
    slog.Error("query failed", "error", err)
    return fmt.Errorf("query: %w", err)
}

// ✓ Good — return with context, log once at the top level
if err != nil {
    return fmt.Errorf("querying users: %w", err)
}

// ✗ Bad — high-cardinality label (unbounded user IDs)
httpRequests.WithLabelValues(r.Method, r.URL.Path, userID).Inc()

// ✓ Good — bounded label values only
httpRequests.WithLabelValues(r.Method, routePattern).Inc()

// ✗ Bad — not passing context (breaks trace propagation)
result, err := db.Query("SELECT ...")

// ✓ Good — context flows through, trace continues
result, err := db.QueryContext(ctx, "SELECT ...")

// ✗ Bad — using Summary for latency (can't aggregate across instances)
prometheus.NewSummary(prometheus.SummaryOpts{
    Name:       "http_request_duration_seconds",
    Objectives: map[float64]float64{0.99: 0.001},
})

// ✓ Good — use Histogram (aggregatable, supports histogram_quantile)
prometheus.NewHistogram(prometheus.HistogramOpts{
    Name:    "http_request_duration_seconds",
    Buckets: prometheus.DefBuckets,
})

© context-labs, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 8 other files (references) in .agents/skills/golang-observability of context-labs/whip.

• SKILL.md
• evals/evals.json
• references/alerting.md
• references/dashboards.md
• references/logging.md
• references/metrics.md
• references/profiling.md
• references/rum.md
• references/tracing.md

Open the folder on GitHubat commit 8876467

Used in 1 other repository

We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in context-labs/whip, which our catalogue first saw on October 7, 2026.

• samber/cc-skills-golangskills/golang-observability