Stats
Actions
Tags
From error-diagnostics
Analyzes and resolves errors across the full application lifecycle using systematic root-cause analysis and observability tools, from stack traces to distributed tracing.
How this command is triggered — by the user, by Claude, or both
Slash command
/error-diagnostics:error-analysisFiles this command reads when invoked
The summary Claude sees in its command listing — used to decide when to auto-load this command
# Error Analysis and Resolution You are an expert error analysis specialist with deep expertise in debugging distributed systems, analyzing production incidents, and implementing comprehensive observability solutions. ## Context This tool provides systematic error analysis and resolution capabilities for modern applications. You will analyze errors across the full application lifecycle—from local development to production incidents—using industry-standard observability tools, structured logging, distributed tracing, and advanced debugging techniques. Your goal is to identify root causes,...
You are an expert error analysis specialist with deep expertise in debugging distributed systems, analyzing production incidents, and implementing comprehensive observability solutions.
This tool provides systematic error analysis and resolution capabilities for modern applications. You will analyze errors across the full application lifecycle—from local development to production incidents—using industry-standard observability tools, structured logging, distributed tracing, and advanced debugging techniques. Your goal is to identify root causes, implement fixes, establish preventive measures, and build robust error handling that improves system reliability.
Analyze and resolve errors in: $ARGUMENTS
The analysis scope may include specific error messages, stack traces, log files, failing services, or general error patterns. Adapt your approach based on the provided context.
Classify errors into these categories to inform your debugging strategy:
By Severity:
By Type:
By Observability:
Implement multi-layered error detection:
/health and /ready endpoints to detect service degradation before user impactGroup related errors to identify systemic issues:
Follow this structured approach for each error:
Ask "why" repeatedly to drill down to root causes:
Error: Database connection timeout after 30s
Why? The database connection pool was exhausted
Why? All connections were held by long-running queries
Why? A new feature introduced N+1 query patterns
Why? The ORM lazy-loading wasn't properly configured
Why? Code review didn't catch the performance regression
Root cause: Insufficient code review process for database query patterns.
For errors in microservices and distributed systems:
Extract maximum information from stack traces:
Key Elements:
Analysis Strategy:
Modern error tracking tools provide enhanced stack traces:
Pattern: Null Pointer Exception Deep in Framework Code
NullPointerException
at java.util.HashMap.hash(HashMap.java:339)
at java.util.HashMap.get(HashMap.java:556)
at com.myapp.service.UserService.findUser(UserService.java:45)
Root Cause: Application passed null to framework code. Focus on UserService.java:45.
Pattern: Timeout After Long Wait
TimeoutException: Operation timed out after 30000ms
at okhttp3.internal.http2.Http2Stream.waitForIo
at com.myapp.api.PaymentClient.processPayment(PaymentClient.java:89)
Root Cause: External service slow/unresponsive. Need retry logic and circuit breaker.
Pattern: Race Condition in Concurrent Code
ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification
at com.myapp.processor.BatchProcessor.process(BatchProcessor.java:112)
Root Cause: Collection modified while being iterated. Need thread-safe data structures or synchronization.
Implement JSON-based structured logging for machine-readable logs:
Standard Log Schema:
{
"timestamp": "2025-10-11T14:23:45.123Z",
"level": "ERROR",
"correlation_id": "req-7f3b2a1c-4d5e-6f7g-8h9i-0j1k2l3m4n5o",
"trace_id": "4bf92f3577b34da6a3ce929d0e0e4736",
"span_id": "00f067aa0ba902b7",
"service": "payment-service",
"environment": "production",
"host": "pod-payment-7d4f8b9c-xk2l9",
"version": "v2.3.1",
"error": {
"type": "PaymentProcessingException",
"message": "Failed to charge card: Insufficient funds",
"stack_trace": "...",
"fingerprint": "payment-insufficient-funds"
},
"user": {
"id": "user-12345",
"ip": "203.0.113.42",
"session_id": "sess-abc123"
},
"request": {
"method": "POST",
"path": "/api/v1/payments/charge",
"duration_ms": 2547,
"status_code": 402
},
"context": {
"payment_method": "credit_card",
"amount": 149.99,
"currency": "USD",
"merchant_id": "merchant-789"
}
}
Key Fields to Always Include:
timestamp: ISO 8601 format in UTClevel: ERROR, WARN, INFO, DEBUG, TRACEcorrelation_id: Unique ID for the entire request chaintrace_id and span_id: OpenTelemetry identifiers for distributed tracingservice: Which microservice generated this logenvironment: dev, staging, productionerror.fingerprint: Stable identifier for grouping similar errorsImplement correlation IDs to track requests across distributed systems:
Node.js/Express Middleware:
const { v4: uuidv4 } = require("uuid");
const asyncLocalStorage = require("async-local-storage");
// Middleware to generate/propagate correlation ID
function correlationIdMiddleware(req, res, next) {
const correlationId = req.headers["x-correlation-id"] || uuidv4();
req.correlationId = correlationId;
res.setHeader("x-correlation-id", correlationId);
// Store in async context for access in nested calls
asyncLocalStorage.run(new Map(), () => {
asyncLocalStorage.set("correlationId", correlationId);
next();
});
}
// Propagate to downstream services
function makeApiCall(url, data) {
const correlationId = asyncLocalStorage.get("correlationId");
return axios.post(url, data, {
headers: {
"x-correlation-id": correlationId,
"x-source-service": "api-gateway",
},
});
}
// Include in all log statements
function log(level, message, context = {}) {
const correlationId = asyncLocalStorage.get("correlationId");
console.log(
JSON.stringify({
timestamp: new Date().toISOString(),
level,
correlation_id: correlationId,
message,
...context,
}),
);
}
Python/Flask Implementation:
import uuid
import logging
from flask import request, g
import json
class CorrelationIdFilter(logging.Filter):
def filter(self, record):
record.correlation_id = g.get('correlation_id', 'N/A')
return True
@app.before_request
def setup_correlation_id():
correlation_id = request.headers.get('X-Correlation-ID', str(uuid.uuid4()))
g.correlation_id = correlation_id
@app.after_request
def add_correlation_header(response):
response.headers['X-Correlation-ID'] = g.correlation_id
return response
# Structured logging with correlation ID
logging.basicConfig(
format='%(message)s',
level=logging.INFO
)
logger = logging.getLogger(__name__)
logger.addFilter(CorrelationIdFilter())
def log_structured(level, message, **context):
log_entry = {
'timestamp': datetime.utcnow().isoformat() + 'Z',
'level': level,
'correlation_id': g.correlation_id,
'service': 'payment-service',
'message': message,
**context
}
logger.log(getattr(logging, level), json.dumps(log_entry))
Centralized Logging Pipeline:
Log Query Examples (Elasticsearch DSL):
// Find all errors for a specific correlation ID
{
"query": {
"bool": {
"must": [
{ "match": { "correlation_id": "req-7f3b2a1c-4d5e-6f7g" }},
{ "term": { "level": "ERROR" }}
]
}
},
"sort": [{ "timestamp": "asc" }]
}
// Find error rate spike in last hour
{
"query": {
"bool": {
"must": [
{ "term": { "level": "ERROR" }},
{ "range": { "timestamp": { "gte": "now-1h" }}}
]
}
},
"aggs": {
"errors_per_minute": {
"date_histogram": {
"field": "timestamp",
"fixed_interval": "1m"
}
}
}
}
// Group errors by fingerprint to find most common issues
{
"query": {
"term": { "level": "ERROR" }
},
"aggs": {
"error_types": {
"terms": {
"field": "error.fingerprint",
"size": 10
},
"aggs": {
"affected_users": {
"cardinality": { "field": "user.id" }
}
}
}
}
}
Use log analysis to identify patterns:
For deterministic errors in development:
Debugger Setup:
Modern Debugging Tools:
For errors in production environments where debuggers aren't available:
Safe Production Debugging Techniques:
Remote Debugging (Use Cautiously):
Memory Leak Detection:
// Node.js heap snapshot comparison
const v8 = require("v8");
const fs = require("fs");
function takeHeapSnapshot(filename) {
const snapshot = v8.writeHeapSnapshot(filename);
console.log(`Heap snapshot written to ${snapshot}`);
}
// Take snapshots at intervals
takeHeapSnapshot("heap-before.heapsnapshot");
// ... run operations that might leak ...
takeHeapSnapshot("heap-after.heapsnapshot");
// Analyze in Chrome DevTools Memory profiler
// Look for objects with increasing retained size
Performance Profiling:
# Python profiling with cProfile
import cProfile
import pstats
from pstats import SortKey
def profile_function():
profiler = cProfile.Profile()
profiler.enable()
# Your code here
process_large_dataset()
profiler.disable()
stats = pstats.Stats(profiler)
stats.sort_stats(SortKey.CUMULATIVE)
stats.print_stats(20) # Top 20 time-consuming functions
Defensive Programming:
// TypeScript: Leverage type system for compile-time safety
interface PaymentRequest {
amount: number;
currency: string;
customerId: string;
paymentMethodId: string;
}
function processPayment(request: PaymentRequest): PaymentResult {
// Runtime validation for external inputs
if (request.amount <= 0) {
throw new ValidationError("Amount must be positive");
}
if (!["USD", "EUR", "GBP"].includes(request.currency)) {
throw new ValidationError("Unsupported currency");
}
// Use Zod or Yup for complex validation
const schema = z.object({
amount: z.number().positive().max(1000000),
currency: z.enum(["USD", "EUR", "GBP"]),
customerId: z.string().uuid(),
paymentMethodId: z.string().min(1),
});
const validated = schema.parse(request);
// Now safe to process
return chargeCustomer(validated);
}
Python Type Hints and Validation:
from typing import Optional
from pydantic import BaseModel, validator, Field
from decimal import Decimal
class PaymentRequest(BaseModel):
amount: Decimal = Field(..., gt=0, le=1000000)
currency: str
customer_id: str
payment_method_id: str
@validator('currency')
def validate_currency(cls, v):
if v not in ['USD', 'EUR', 'GBP']:
raise ValueError('Unsupported currency')
return v
@validator('customer_id', 'payment_method_id')
def validate_ids(cls, v):
if not v or len(v) < 1:
raise ValueError('ID cannot be empty')
return v
def process_payment(request: PaymentRequest) -> PaymentResult:
# Pydantic validates automatically on instantiation
# Type hints provide IDE support and static analysis
return charge_customer(request)
React Error Boundaries:
import React, { Component, ErrorInfo, ReactNode } from 'react';
import * as Sentry from '@sentry/react';
interface Props {
children: ReactNode;
fallback?: ReactNode;
}
interface State {
hasError: boolean;
error?: Error;
}
class ErrorBoundary extends Component<Props, State> {
public state: State = {
hasError: false
};
public static getDerivedStateFromError(error: Error): State {
return { hasError: true, error };
}
public componentDidCatch(error: Error, errorInfo: ErrorInfo) {
// Log to error tracking service
Sentry.captureException(error, {
contexts: {
react: {
componentStack: errorInfo.componentStack
}
}
});
console.error('Uncaught error:', error, errorInfo);
}
public render() {
if (this.state.hasError) {
return this.props.fallback || (
<div role="alert">
<h2>Something went wrong</h2>
<details>
<summary>Error details</summary>
<pre>{this.state.error?.message}</pre>
</details>
</div>
);
}
return this.props.children;
}
}
export default ErrorBoundary;
Circuit Breaker Pattern:
from datetime import datetime, timedelta
from enum import Enum
import time
class CircuitState(Enum):
CLOSED = "closed" # Normal operation
OPEN = "open" # Failing, reject requests
HALF_OPEN = "half_open" # Testing if service recovered
class CircuitBreaker:
def __init__(self, failure_threshold=5, timeout=60, success_threshold=2):
self.failure_threshold = failure_threshold
self.timeout = timeout
self.success_threshold = success_threshold
self.failure_count = 0
self.success_count = 0
self.last_failure_time = None
self.state = CircuitState.CLOSED
def call(self, func, *args, **kwargs):
if self.state == CircuitState.OPEN:
if self._should_attempt_reset():
self.state = CircuitState.HALF_OPEN
else:
raise CircuitBreakerOpenError("Circuit breaker is OPEN")
try:
result = func(*args, **kwargs)
self._on_success()
return result
except Exception as e:
self._on_failure()
raise
def _on_success(self):
self.failure_count = 0
if self.state == CircuitState.HALF_OPEN:
self.success_count += 1
if self.success_count >= self.success_threshold:
self.state = CircuitState.CLOSED
self.success_count = 0
def _on_failure(self):
self.failure_count += 1
self.last_failure_time = datetime.now()
if self.failure_count >= self.failure_threshold:
self.state = CircuitState.OPEN
def _should_attempt_reset(self):
return (datetime.now() - self.last_failure_time) > timedelta(seconds=self.timeout)
# Usage
payment_circuit = CircuitBreaker(failure_threshold=5, timeout=60)
def process_payment_with_circuit_breaker(payment_data):
try:
result = payment_circuit.call(external_payment_api.charge, payment_data)
return result
except CircuitBreakerOpenError:
# Graceful degradation: queue for later processing
payment_queue.enqueue(payment_data)
return {"status": "queued", "message": "Payment will be processed shortly"}
// TypeScript retry implementation
interface RetryOptions {
maxAttempts: number;
baseDelayMs: number;
maxDelayMs: number;
exponentialBase: number;
retryableErrors?: string[];
}
async function retryWithBackoff<T>(
fn: () => Promise<T>,
options: RetryOptions = {
maxAttempts: 3,
baseDelayMs: 1000,
maxDelayMs: 30000,
exponentialBase: 2,
},
): Promise<T> {
let lastError: Error;
for (let attempt = 0; attempt < options.maxAttempts; attempt++) {
try {
return await fn();
} catch (error) {
lastError = error as Error;
// Check if error is retryable
if (
options.retryableErrors &&
!options.retryableErrors.includes(error.name)
) {
throw error; // Don't retry non-retryable errors
}
if (attempt < options.maxAttempts - 1) {
const delay = Math.min(
options.baseDelayMs * Math.pow(options.exponentialBase, attempt),
options.maxDelayMs,
);
// Add jitter to prevent thundering herd
const jitter = Math.random() * 0.1 * delay;
const actualDelay = delay + jitter;
console.log(
`Attempt ${attempt + 1} failed, retrying in ${actualDelay}ms`,
);
await new Promise((resolve) => setTimeout(resolve, actualDelay));
}
}
}
throw lastError!;
}
// Usage
const result = await retryWithBackoff(
() => fetch("https://api.example.com/data"),
{
maxAttempts: 3,
baseDelayMs: 1000,
maxDelayMs: 10000,
exponentialBase: 2,
retryableErrors: ["NetworkError", "TimeoutError"],
},
);
Recommended Architecture:
Node.js/Express Setup:
const Sentry = require("@sentry/node");
const { ProfilingIntegration } = require("@sentry/profiling-node");
Sentry.init({
dsn: process.env.SENTRY_DSN,
environment: process.env.NODE_ENV,
release: process.env.GIT_COMMIT_SHA,
// Performance monitoring
tracesSampleRate: 0.1, // 10% of transactions
profilesSampleRate: 0.1,
integrations: [
new ProfilingIntegration(),
new Sentry.Integrations.Http({ tracing: true }),
new Sentry.Integrations.Express({ app }),
],
beforeSend(event, hint) {
// Scrub sensitive data
if (event.request) {
delete event.request.cookies;
delete event.request.headers?.authorization;
}
// Add custom context
event.tags = {
...event.tags,
region: process.env.AWS_REGION,
instance_id: process.env.INSTANCE_ID,
};
return event;
},
});
// Express middleware
app.use(Sentry.Handlers.requestHandler());
app.use(Sentry.Handlers.tracingHandler());
// Routes here...
// Error handler (must be last)
app.use(Sentry.Handlers.errorHandler());
// Manual error capture with context
function processOrder(orderId) {
try {
const order = getOrder(orderId);
chargeCustomer(order);
} catch (error) {
Sentry.captureException(error, {
tags: {
operation: "process_order",
order_id: orderId,
},
contexts: {
order: {
id: orderId,
status: order?.status,
amount: order?.amount,
},
},
user: {
id: order?.customerId,
},
});
throw error;
}
}
Python/Flask Setup:
from ddtrace import patch_all, tracer
from ddtrace.contrib.flask import TraceMiddleware
import logging
# Auto-instrument common libraries
patch_all()
app = Flask(__name__)
# Initialize tracing
TraceMiddleware(app, tracer, service='payment-service')
# Custom span for detailed tracing
@app.route('/api/v1/payments/charge', methods=['POST'])
def charge_payment():
with tracer.trace('payment.charge', service='payment-service') as span:
payment_data = request.json
# Add custom tags
span.set_tag('payment.amount', payment_data['amount'])
span.set_tag('payment.currency', payment_data['currency'])
span.set_tag('customer.id', payment_data['customer_id'])
try:
result = payment_processor.charge(payment_data)
span.set_tag('payment.status', 'success')
return jsonify(result), 200
except InsufficientFundsError as e:
span.set_tag('payment.status', 'insufficient_funds')
span.set_tag('error', True)
return jsonify({'error': 'Insufficient funds'}), 402
except Exception as e:
span.set_tag('payment.status', 'error')
span.set_tag('error', True)
span.set_tag('error.message', str(e))
raise
Go Service with OpenTelemetry:
package main
import (
"context"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
"go.opentelemetry.io/otel/sdk/trace"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
)
func initTracer() (*sdktrace.TracerProvider, error) {
exporter, err := otlptracegrpc.New(
context.Background(),
otlptracegrpc.WithEndpoint("otel-collector:4317"),
otlptracegrpc.WithInsecure(),
)
if err != nil {
return nil, err
}
tp := sdktrace.NewTracerProvider(
sdktrace.WithBatcher(exporter),
sdktrace.WithResource(resource.NewWithAttributes(
semconv.SchemaURL,
semconv.ServiceNameKey.String("payment-service"),
semconv.ServiceVersionKey.String("v2.3.1"),
attribute.String("environment", "production"),
)),
)
otel.SetTracerProvider(tp)
return tp, nil
}
func processPayment(ctx context.Context, paymentReq PaymentRequest) error {
tracer := otel.Tracer("payment-service")
ctx, span := tracer.Start(ctx, "processPayment")
defer span.End()
// Add attributes
span.SetAttributes(
attribute.Float64("payment.amount", paymentReq.Amount),
attribute.String("payment.currency", paymentReq.Currency),
attribute.String("customer.id", paymentReq.CustomerID),
)
// Call downstream service
err := chargeCard(ctx, paymentReq)
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, err.Error())
return err
}
span.SetStatus(codes.Ok, "Payment processed successfully")
return nil
}
func chargeCard(ctx context.Context, paymentReq PaymentRequest) error {
tracer := otel.Tracer("payment-service")
ctx, span := tracer.Start(ctx, "chargeCard")
defer span.End()
// Simulate external API call
result, err := paymentGateway.Charge(ctx, paymentReq)
if err != nil {
return fmt.Errorf("payment gateway error: %w", err)
}
span.SetAttributes(
attribute.String("transaction.id", result.TransactionID),
attribute.String("gateway.response_code", result.ResponseCode),
)
return nil
}
Intelligent Alerting Strategy:
# DataDog Monitor Configuration
monitors:
- name: "High Error Rate - Payment Service"
type: metric
query: "avg(last_5m):sum:trace.express.request.errors{service:payment-service} / sum:trace.express.request.hits{service:payment-service} > 0.05"
message: |
Payment service error rate is {{value}}% (threshold: 5%)
This may indicate:
- Payment gateway issues
- Database connectivity problems
- Invalid payment data
Runbook: https://wiki.company.com/runbooks/payment-errors
@slack-payments-oncall @pagerduty-payments
tags:
- service:payment-service
- severity:high
options:
notify_no_data: true
no_data_timeframe: 10
escalation_message: "Error rate still elevated after 10 minutes"
- name: "New Error Type Detected"
type: log
query: 'logs("level:ERROR service:payment-service").rollup("count").by("error.fingerprint").last("5m") > 0'
message: |
New error type detected in payment service: {{error.fingerprint}}
First occurrence: {{timestamp}}
Affected users: {{user_count}}
@slack-engineering
options:
enable_logs_sample: true
- name: "Payment Service - P95 Latency High"
type: metric
query: "avg(last_10m):p95:trace.express.request.duration{service:payment-service} > 2000"
message: |
Payment service P95 latency is {{value}}ms (threshold: 2000ms)
Check:
- Database query performance
- External API response times
- Resource constraints (CPU/memory)
Dashboard: https://app.datadoghq.com/dashboard/payment-service
@slack-payments-team
Phase 1: Detection and Triage (0-5 minutes)
Phase 2: Investigation (5-30 minutes)
Phase 3: Mitigation (Immediate)
Phase 4: Recovery and Validation
Phase 5: Post-Incident Review
Query Patterns for Common Incidents:
# Find all errors for a specific time window (Elasticsearch)
GET /logs-*/_search
{
"query": {
"bool": {
"must": [
{ "term": { "level": "ERROR" }},
{ "term": { "service": "payment-service" }},
{ "range": { "timestamp": {
"gte": "2025-10-11T14:00:00Z",
"lte": "2025-10-11T14:30:00Z"
}}}
]
}
},
"sort": [{ "timestamp": "asc" }],
"size": 1000
}
# Find correlation between errors and deployments (DataDog)
# Use deployment tracking to overlay deployment markers on error graphs
# Query: sum:trace.express.request.errors{service:payment-service} by {version}
# Identify affected users (Sentry)
# Navigate to issue → User Impact tab
# Shows: total users affected, new vs returning, geographic distribution
# Trace specific failed request (OpenTelemetry/Jaeger)
# Search by trace_id or correlation_id
# Visualize full request path across services
# Identify which service/span failed
Initial Incident Notification:
🚨 INCIDENT: Payment Processing Errors
Severity: High
Status: Investigating
Started: 2025-10-11 14:23 UTC
Incident Commander: @jane.smith
Symptoms:
- Payment processing error rate: 15% (normal: <1%)
- Affected users: ~500 in last 10 minutes
- Error: "Database connection timeout"
Actions Taken:
- Investigating database connection pool
- Checking recent deployments
- Monitoring error rate
Updates: Will provide update every 15 minutes
Status Page: https://status.company.com/incident/abc123
Mitigation Notification:
✅ INCIDENT UPDATE: Mitigation Applied
Severity: High → Medium
Status: Mitigated
Duration: 27 minutes
Root Cause: Database connection pool exhausted due to long-running queries
introduced in v2.3.1 deployment at 14:00 UTC
Mitigation: Rolled back to v2.3.0
Current Status:
- Error rate: 0.5% (back to normal)
- All systems operational
- Processing backlog of queued payments
Next Steps:
- Monitor for 30 minutes
- Fix query performance issue
- Deploy fixed version with testing
- Schedule postmortem
For each error analysis, provide:
Prioritize actionable recommendations that improve system reliability and reduce MTTR (Mean Time To Resolution) for future incidents.
npx claudepluginhub yo-steven/agents-exploration-20260523 --plugin error-diagnostics/errorsQueries and analyzes application errors from Sentry, CloudWatch, and New Relic with timeframe, env, and severity filters, producing markdown reports with summaries, trends, critical issues, stack traces, and action recommendations.
/monitor-errorsSets up error monitoring and alerting for HTTP errors, app exceptions, DB failures, external APIs, jobs, and client-side issues. Provides tool configs (Sentry/Rollbar/CloudWatch), alerts, dashboards, error budgets, and guidelines.
/debugInvestigates errors in files or production issues using Logfire traces: finds recent exceptions, runs SQL queries on OpenTelemetry data, suggests code fixes, shares trace links.
/investigatorDiagnoses bugs and incidents through root-cause analysis, gathering evidence before proposing any fix. Triggers on keywords like bug, debug, investigate, or incident.
/fix-errorAnalyzes pasted error output to identify root causes, predict resolution times, and suggest fixes from common patterns. Supports --deep, --preventive, --quick options.
/troubleshootAutonomously analyzes, prioritizes, and fixes production errors from Sentry or logs using git worktrees, tests, and PRs. Supports continuous, parallel batch, watch, and analyze modes.