observability-monitoring

Production visibility through logs, metrics, traces, and alerting — the three pillars of observability

Repositorio: fabioc-aloha/Alex_Plug_In
Última actividad en el origen: 15 de abril de 2026 a las 05:03
Idioma detectado de SKILL.md: inglés
Estrellas: 5
Forks: 3

Opciones de instalación

De forma predeterminada está seleccionado el prompt que primero revisa el origen. Puedes cambiar a un comando directo o descargar una copia local.

Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.

Un comando directo omite el prompt de revisión. Revisa el origen antes de ejecutarlo.

npx skills add https://github.com/fabioc-aloha/Alex_Plug_In --skill observability-monitoring

El comando permanece en una sola línea. Desplázate horizontalmente para revisarlo antes de copiarlo.

¿Prefieres una copia local? Descarga los archivos que SkillsMP tiene disponibles ahora.

Revisa los archivos de origen

Lee SKILL.md y los archivos complementarios que muestra SkillsMP antes de decidir si quieres instalarlo.

SKILL.md

Instrucciones de origen · Vista previa de solo lectura

Volver a la búsqueda Volver a la instalación

ascii-project-dashboard

Create and maintain ASCII visual dashboards for project tracking with parallel lane progress bars

2026-04-15

audio-memory

Store and manage voice samples for TTS cloning — portable, version-controlled audio references

2026-04-15

markdown-mermaid

Clear documentation through visual excellence

2026-04-15

Ver todos los de este repositorio

Level	Usage	Example
ERROR	Something failed, needs attention	Payment failed
WARN	Unexpected but handled	Retry succeeded
INFO	Business events	User logged in
DEBUG	Developer details	Cache hit/miss
TRACE	Verbose internals	Function entry/exit

// Middleware to propagate trace ID
app.use((req, res, next) => {
  req.traceId = req.headers['x-trace-id'] || uuid();
  res.setHeader('x-trace-id', req.traceId);
  next();
});

// Include in all logs
logger.info('Processing request', { traceId: req.traceId, ...data });

Trace: user-checkout-abc123
├── Span: api-gateway (50ms)
│   ├── Span: auth-service (10ms)
│   └── Span: order-service (35ms)
│       ├── Span: inventory-check (8ms)
│       └── Span: payment-service (20ms)
│           └── Span: database-write (5ms)

// OpenTelemetry automatic propagation
import { trace, context, propagation } from '@opentelemetry/api';

// Extract context from incoming request
const ctx = propagation.extract(context.active(), req.headers);

// Create span with parent context
const span = tracer.startSpan('process-order', undefined, ctx);

// Propagate to outgoing request
propagation.inject(context.active(), headers);

// tracing.ts - Load FIRST
import { NodeSDK } from '@opentelemetry/sdk-node';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'http://localhost:4318/v1/traces',
  }),
  instrumentations: [getNodeAutoInstrumentations()],
});

sdk.start();

// Program.cs
builder.Services.AddOpenTelemetry()
    .WithTracing(tracing => tracing
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddOtlpExporter());

alert: HighErrorRate
expr: sum(rate(http_errors_total[5m])) / sum(rate(http_requests_total[5m])) > 0.05
for: 5m
labels:
  severity: high
  team: backend
annotations:
  summary: "Error rate above 5%"
  runbook: "https://runbooks.example.com/high-error-rate"
  dashboard: "https://grafana.example.com/d/errors"

┌─────────────────────────────────────────────────────────┐
│                   SERVICE HEALTH                         │
│  [Status] [Error Rate] [Latency P50] [Latency P99]      │
├─────────────────────────────────────────────────────────┤
│                   TRAFFIC                                │
│  [Requests/sec graph over time]                         │
├─────────────────────────────────────────────────────────┤
│           ERRORS             │        LATENCY           │
│  [Error breakdown by type]   │  [Latency histogram]     │
├─────────────────────────────────────────────────────────┤
│                   RESOURCES                              │
│  [CPU] [Memory] [Disk] [Network]                        │
└─────────────────────────────────────────────────────────┘

// Node.js
import { useAzureMonitor } from '@azure/monitor-opentelemetry';

useAzureMonitor({
  azureMonitorExporterOptions: {
    connectionString: process.env.APPLICATIONINSIGHTS_CONNECTION_STRING
  }
});

import * as vscode from 'vscode';

const telemetry = vscode.env.createTelemetryLogger({
  sendEventData(eventName, data) {
    // Send to your telemetry backend
  },
  sendErrorData(error, data) {
    // Send errors with context
  }
});

// Usage
telemetry.logUsage('command.executed', {
  commandId: 'alex.meditate',
  durationMs: 1500
});

name	observability-monitoring
description	Production visibility through logs, metrics, traces, and alerting — the three pillars of observability
tier	standard
applyTo	*/observ,/monitor,/telemetry,/logging,/metrics,/traces*

Pillar	What	When	Tools
Logs	Discrete events	Debugging, auditing	Winston, Pino, Serilog
Metrics	Aggregated measurements	Alerting, dashboards	Prometheus, CloudWatch
Traces	Request flow across services	Distributed debugging	Jaeger, Zipkin

name	observability-monitoring
description	Production visibility through logs, metrics, traces, and alerting — the three pillars of observability
tier	standard
applyTo	*/observ,/monitor,/telemetry,/logging,/metrics,/traces*

Pillar	What	When	Tools
Logs	Discrete events	Debugging, auditing	Winston, Pino, Serilog
Metrics	Aggregated measurements	Alerting, dashboards	Prometheus, CloudWatch
Traces	Request flow across services	Distributed debugging	Jaeger, Zipkin

Type	Use Case	Example
Counter	Cumulative totals	requests_total
Gauge	Current value	temperature, queue_size
Histogram	Value distribution	request_duration_seconds
Summary	Quantiles	response_time_p99

Severity	Response	Example
P1/Critical	Wake someone up	Service down
P2/High	Fix within hours	Error rate > 5%
P3/Medium	Fix within days	Disk 80%
P4/Low	Fix when convenient	Deprecation warning

Cloud	Metrics	Logs	Traces
Azure	Azure Monitor	Log Analytics	App Insights
AWS	CloudWatch	CloudWatch Logs	X-Ray
GCP	Cloud Monitoring	Cloud Logging	Cloud Trace

Metric	Why
Command execution time	User experience
Activation time	Startup performance
Error rates by command	Reliability
Memory usage	Resource efficiency
API call latency	External dependencies

observability-monitoring

Datos de origen

Opciones de instalación

Revisa los archivos de origen

Más de este repositorio

Más de este repositorio

Observability & Monitoring Skill

The Three Pillars

Logging Best Practices

Structured Logging

Observability & Monitoring Skill

The Three Pillars

Logging Best Practices

Structured Logging

Log Levels

Correlation IDs

Metrics Patterns

The RED Method (Request-focused)

The USE Method (Resource-focused)

Key Metric Types

Golden Signals (SRE)

Distributed Tracing

Span Structure

Context Propagation

OpenTelemetry Setup

Node.js Quick Start

.NET Quick Start

Alerting Strategy

Alert Hierarchy

Alert Anti-Patterns

Good Alert Template

Dashboard Design

Layout Principles

Dashboard Hierarchy

Cloud Provider Tools

Azure Application Insights

VS Code Extension Observability

What to Monitor

Telemetry Implementation

Debugging Patterns

Log-Driven Debugging

Trace-Driven Debugging

Metric-Driven Debugging

Implementation Checklist

New Service

Production Readiness

Related Skills