opentelemetry · julianobarbosa — Claude Code skill: what it does, how to install
A skill that walks the agent through OpenTelemetry work: collector config, rollout to Kubernetes, pipelines for traces, metrics and logs.
MIT 135 installs ★ 17 updated 2026-10-14
npx skills add julianobarbosa/claude-code-skills --skill opentelemetry -a claude-codeWhat opentelemetry does
The skill gives the agent the pieces for a collector running in a cluster: a Helm install into a monitoring namespace as a DaemonSet, a YAML skeleton with otlp receivers on 4317 and 4318, memory_limiter and batch processors, exporters to Prometheus and Loki. A k8sattributes example adds pod and namespace metadata to the telemetry.
It covers DaemonSet, Deployment and sidecar layouts and what each one suits. kubectl checks are there too, along with otelcol validate --config=config.yaml for catching a broken config before rollout.
Most useful is the gotchas list. memory_limiter has to sit ahead of batch in the pipeline, or memory pressure drops batches with no backpressure. The same list flags doubled traces when auto- and manual instrumentation run side by side, and B3 headers that never turn into W3C traceparent on their own.
What it helps with
- wire traces, metrics and logs into one collector config
- deploy the OTEL Collector to Kubernetes with Helm
- tag telemetry with pod and namespace names
- pick between DaemonSet, Deployment and sidecar
- validate collector config before rollout
Example prompts for the agent
- Deploy the OTEL Collector into the
monitoringnamespace as a daemonset and turn on host metrics. - Write a collector config with
otlpon 4317 and 4318 and putmemory_limiterbeforebatch. - Why do traces break between services where some send B3 and others send W3C
traceparent?
How to install opentelemetry
1Skills CLI (Vercel)
npx skills add julianobarbosa/claude-code-skills --skill opentelemetry -a claude-code2Manually: put the files in place
~/.claude/skills/opentelemetry/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/opentelemetry/
1Skills CLI (Vercel)
npx skills add julianobarbosa/claude-code-skills --skill opentelemetry -a codex2Manually: put the files in place
.agents/skills/opentelemetry/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add julianobarbosa/claude-code-skills --skill opentelemetry -a cursor2Manually: put the files in place
.cursor/skills/opentelemetry/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install julianobarbosa/claude-code-skills skills/opentelemetry2Manually: put the files in place
.github/skills/opentelemetry/SKILL.md1Skills CLI (Vercel)
npx skills add julianobarbosa/claude-code-skills --skill opentelemetry -a gemini-cli2Platform CLI
gemini skills install https://github.com/julianobarbosa/claude-code-skills --path skills/opentelemetryManually: put the files in place
.devin/skills/opentelemetry/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add julianobarbosa/claude-code-skills --skill opentelemetry -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about opentelemetry
How do I install opentelemetry in Claude Code?
Run npx skills add julianobarbosa/claude-code-skills --skill opentelemetry -a claude-code. The skill file lands at ~/.claude/skills/opentelemetry/SKILL.md.
What does the opentelemetry skill do?
It helps the agent write collector configuration and deploy it to a cluster: receivers, processors, exporters, the three deployment modes, plus commands to check the result.
Why does processor order matter in the pipeline?
With batch ahead of memory_limiter, memory pressure drops batches and nothing pushes back. The limiter has to come first.
Source text
SKILL.md · MIT
---
name: opentelemetry
description: Implement OpenTelemetry (OTEL) observability - Collector configuration, Kubernetes deployment, traces/metrics/logs pipelines, instrumentation, and troubleshooting. Use when working with OTEL Collector, telemetry pipelines, observability infrastructure, or Kubernetes monitoring.
---
# OpenTelemetry Implementation Guide
## Overview
OpenTelemetry (OTel) is a vendor-neutral observability framework for instrumenting, generating, collecting, and exporting telemetry data (traces, metrics, logs). This skill provides guidance for implementing OTEL in Kubernetes environments.
## Quick Start
### Deploy OTEL Collector on Kubernetes
```bash
# Add Helm repo
helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
helm repo update
# Install with basic config
helm install otel-collector open-telemetry/opentelemetry-collector \
--namespace monitoring --create-namespace \
--set mode=daemonset
```
### Send Test Data via OTLP
```bash
# gRPC endpoint: 4317, HTTP endpoint: 4318
curl -X POST http://otel-collector:4318/v1/traces \
-H "Content-Type: application/json" \
-d '{"resourceSpans":[]}'
```
## Core Concepts
**Signals**: Three types of telemetry data:
- **Traces**: Distributed request flows across services
- **Metrics**: Numerical measurements (counters, gauges, histograms)
- **Logs**: Event records with structured/unstructured data
**Collector Components**:
- **Receivers**: Accept data (OTLP, Prometheus, Jaeger, Zipkin)
- **Processors**: Transform data (batch, memory_limiter, k8sattributes)
- **Exporters**: Send data (prometheusremotewrite, loki, otlp)
- **Extensions**: Add capabilities (health_check, pprof, zpages)
## Collector Configuration
### Basic Pipeline Structure
```yaml
config:
receivers:
otlp:
protocols:
grpc:
endpoint: ${env:MY_POD_IP}:4317
http:
endpoint: ${env:MY_POD_IP}:4318
processors:
batch:
timeout: 10s
send_batch_size: 1024
memory_limiter:
check_interval: 5s
limit_percentage: 80
spike_limit_percentage: 25
exporters:
prometheusremotewrite:
endpoint: "http://prometheus:9090/api/v1/write"
loki:
endpoint: "http://loki:3100/loki/api/v1/push"
service:
pipelines:
metrics:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [prometheusremotewrite]
logs:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [loki]
traces:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [otlp/tempo]
```
### Kubernetes Attributes Enrichment
```yaml
processors:
k8sattributes:
auth_type: "serviceAccount"
passthrough: false
filter:
node_from_env_var: ${env:K8S_NODE_NAME}
extract:
metadata:
- k8s.pod.name
- k8s.namespace.name
- k8s.deployment.name
- k8s.node.name
```
## Deployment Modes
| Mode | Use Case | Pros | Cons |
|------|----------|------|------|
| DaemonSet | Node-level collection | Full coverage, host metrics | Higher resource usage |
| Deployment | Centralized gateway | Scalable, easier management | Single point of failure |
| Sidecar | Per-pod collection | Isolated, fine-grained | Resource overhead per pod |
## Common Patterns
### Development Environment
- Enable debug exporter for visibility
- Lower resource limits (250m CPU, 512Mi memory)
- Include spot instance tolerations for cost savings
### Production Environment
- Implement sampling (10-50% for traces)
- Higher batch sizes (2048-4096)
- Enable autoscaling and PodDisruptionBudget
- Use TLS for all endpoints
## Detailed References
For in-depth guidance, see:
- **Collector Configuration**: [COLLECTOR.md](references/COLLECTOR.md)
- **Kubernetes Deployment**: [KUBERNETES.md](references/KUBERNETES.md)
- **Troubleshooting**: [TROUBLESHOOTING.md](references/TROUBLESHOOTING.md)
- **Instrumentation**: [INSTRUMENTATION.md](references/INSTRUMENTATION.md)
## Validation Commands
```bash
# Check collector pods
kubectl get pods -n monitoring -l app.kubernetes.io/name=otel-collector
# View collector logs
kubectl logs -n monitoring -l app.kubernetes.io/name=otel-collector --tail=100
# Test OTLP endpoint
kubectl run test-otlp --image=curlimages/curl:latest --rm -it -- \
curl -v http://otel-collector.monitoring:4318/v1/traces
# Validate config syntax
otelcol validate --config=config.yaml
```
## Key Helm Chart Values
```yaml
mode: "daemonset" # or "deployment"
presets:
logsCollection:
enabled: true
hostMetrics:
enabled: true
kubernetesAttributes:
enabled: true
kubeletMetrics:
enabled: true
useGOMEMLIMIT: true
resources:
limits:
cpu: 500m
memory: 1Gi
requests:
cpu: 100m
memory: 256Mi
```
---
## Gotchas
- **Collector tail_sampling at end of pipeline doesn't release inflight buffer** — drop decisions made late still hold memory; OOM under load.
- **Auto-instrumentation + manual instrumentation can double-count traces** — pick one strategy per service or de-dupe explicitly via sampler.
- **Context propagation**: HTTP B3 vs W3C `traceparent` headers don't auto-convert; mixed environments silently break trace continuity.
- **OTel SDK vs Collector protocol versions**: minor version mismatches can drop attributes silently (especially semantic-convention attributes).
- **Resource detection** adds platform attributes (`cloud.account.id`, `host.id`) that bloat traces — disable when not used for routing.
- **Batch processor + memory limiter ordering**: limiter must precede batch in the pipeline or memory pressure causes batch drops without backpressure.
© julianobarbosa · MIT · julianobarbosa/claude-code-skills
Similar skills
All skills for DevOps and infrastructure →opentelemetry by other authors comes first.