메뉴
Enterprise Application Monitoring with AI-powered observability architecture, Context7 integration, and intelligent performance orchestration for scalable modern applications
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-domain-monitoring명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
Enterprise database architecture specialist with PostgreSQL 17, MySQL 8.4 LTS, MongoDB 8.0, Redis 7.4 expertise. Master connection pooling, query optimization, caching strategies, and database DevOps automation. Build scalable, resilient database systems with comprehensive monitoring and disaster recovery.
Enterprise Frontend Development with AI-powered modern architecture, Context7 integration, and intelligent component orchestration for scalable user interfaces
Enterprise-grade security expertise with production-ready patterns for OWASP Top 10 2021, zero-trust architecture, threat modeling (STRIDE, PASTA), secure SDLC, DevSecOps automation, cloud security, cryptography, identity & access management, and compliance frameworks (SOC 2, ISO 27001, GDPR, CCPA).
SOC 직업 분류 기준
SKILL.md 표시 중
| name | moai-domain-monitoring |
| version | 4.0.0 |
| created | 2025-11-11T00:00:00.000Z |
| updated | 2025-11-13T00:00:00.000Z |
| status | stable |
| description | Enterprise Application Monitoring with AI-powered observability architecture, Context7 integration, and intelligent performance orchestration for scalable modern applications |
| keywords | ["monitoring","observability","performance","analytics","metrics","logging","tracing","context7-integration","ai-orchestration","production-deployment"] |
| allowed-tools | ["Read","Bash","Write","Edit","Glob","Grep","WebFetch","mcp__context7__resolve-library-id","mcp__context7__get-library-docs"] |
| Field | Value |
|---|---|
| Skill Name | moai-domain-monitoring |
| Version | 4.0.0 (2025-11-13) |
| Tier | Enterprise Monitoring Expert |
| AI-Powered | ✅ Context7 Integration, Intelligent Architecture |
| Auto-load | On demand when monitoring keywords detected |
Enterprise Application Monitoring expert with AI-powered observability architecture, Context7 integration, and intelligent performance orchestration for scalable modern applications.
Revolutionary v4.0.0 capabilities:
Automatic triggers:
Manual invocation:
# AI-powered monitoring architecture optimization with Context7
class MonitoringArchitectOptimizer:
def __init__(self):
self.context7_client = Context7Client()
self.observability_analyzer = ObservabilityAnalyzer()
self.performance_optimizer = PerformanceOptimizer()
async def design_optimal_monitoring_architecture(self,
requirements: MonitoringRequirements) -> MonitoringArchitecture:
"""Design optimal monitoring architecture using AI analysis."""
# Get latest monitoring and observability documentation via Context7
monitoring_docs = await self.context7_client.get_library_docs(
context7_library_id='/monitoring/docs',
topic="observability metrics tracing logging alerting 2025",
tokens=3000
)
observability_docs = await self.context7_client.get_library_docs(
context7_library_id='/observability/docs',
topic="opentelemetry prometheus grafana performance 2025",
tokens=2000
)
# Optimize observability stack
observability_design = self.observability_analyzer.optimize_stack(
requirements.application_complexity,
requirements.scale_requirements,
monitoring_docs
)
# Design alerting strategy
alerting_strategy = self.performance_optimizer.design_alerting(
requirements.service_level_objectives,
requirements.notification_preferences,
observability_docs
)
return MonitoringArchitecture(
metrics_collection=self._configure_metrics(requirements),
logging_system=self._configure_logging(requirements),
tracing_setup=self._configure_tracing(requirements),
alerting_framework=alerting_strategy,
observability_stack=observability_design,
dashboard_configuration=self._design_dashboards(requirements),
performance_predictions=observability_design.predictions
)
// Comprehensive OpenTelemetry setup for Node.js applications
import { NodeSDK } from '@opentelemetry/sdk-node';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { Resource } from '@opentelemetry/resources';
import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
import { OTLPTraceExporter } from '@opentelemetry/exporter-otlp-grpc';
import { OTLPMetricExporter } from '@opentelemetry/exporter-otlp-grpc';
import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';
// Initialize OpenTelemetry SDK
const sdk = new NodeSDK({
resource: new Resource({
[SemanticResourceAttributes.SERVICE_NAME]: 'your-service-name',
[SemanticResourceAttributes.SERVICE_VERSION]: '1.0.0',
[SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: process.env.NODE_ENV,
}),
// Auto-instrumentation for popular libraries
instrumentations: [getNodeAutoInstrumentations()],
// Trace exporter for distributed tracing
traceExporter: new OTLPTraceExporter({
url: process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || 'http://jaeger:4317',
}),
// Metrics exporter
metricExporter: new OTLPMetricExporter({
url: process.env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT || 'http://prometheus:9090',
}),
// Additional Prometheus endpoint
metricReader: new PrometheusExporter({
port: 9464,
endpoint: '/metrics',
}),
// Performance optimizations
spanLimits: {
attributeCountLimit: 100,
eventCountLimit: 1000,
linkCountLimit: 100,
},
});
// Start the SDK
sdk.start().then(() => {
console.log('OpenTelemetry initialized successfully');
});
// Graceful shutdown
process.on('SIGTERM', () => {
sdk.shutdown()
.then(() => console.log('OpenTelemetry shut down successfully'))
.catch((error) => console.error('Error shutting down OpenTelemetry', error))
.finally(() => process.exit(0));
});
// Custom span creation for business logic
import { trace } from '@opentelemetry/api';
export function createBusinessSpan(operationName: string, attributes: Record<string, string>) {
const tracer = trace.getTracer('business-logic');
return tracer.startSpan(operationName, {
attributes: {
'business.operation': operationName,
'service.name': 'your-service-name',
...attributes,
},
});
}
// Example usage in business logic
export async function processUserOrder(userId: string, orderId: string) {
const span = createBusinessSpan('process_user_order', {
'user.id': userId,
'order.id': orderId,
});
try {
// Business logic here
const result = await orderService.process(userId, orderId);
span.setAttributes({
'order.status': result.status,
'order.amount': result.amount.toString(),
});
return result;
} catch (error) {
span.recordException(error as Error);
throw error;
} finally {
span.end();
}
}
// Custom Prometheus metrics for application monitoring
import { Counter, Histogram, Gauge, register } from 'prom-client';
// Business metrics
export const businessMetrics = {
// Request counters
httpRequestsTotal: new Counter({
name: 'http_requests_total',
help: 'Total number of HTTP requests',
labelNames: ['method', 'route', 'status_code'],
}),
// Response time histograms
httpRequestDuration: new Histogram({
name: 'http_request_duration_seconds',
help: 'HTTP request duration in seconds',
labelNames: ['method', 'route'],
buckets: [0.1, 0.3, 0.5, 0.7, 1, 3, 5, 7, 10],
}),
// Active connections gauge
activeConnections: new Gauge({
name: 'active_connections',
help: 'Number of active connections',
}),
// Business operations
ordersProcessed: new Counter({
name: 'orders_processed_total',
help: 'Total number of orders processed',
labelNames: ['status', 'payment_method'],
}),
revenueGenerated: new Counter({
name: 'revenue_generated_total',
help: 'Total revenue generated',
labelNames: ['currency'],
}),
};
// System metrics
export const systemMetrics = {
// Memory usage
memoryUsage: new Gauge({
name: 'memory_usage_bytes',
help: 'Memory usage in bytes',
labelNames: ['type'], // heap, external, array_buffers
}),
// CPU usage
cpuUsage: new Gauge({
name: 'cpu_usage_percent',
help: 'CPU usage percentage',
}),
// Event loop lag
eventLoopLag: new Histogram({
name: 'event_loop_lag_seconds',
help: 'Event loop lag in seconds',
buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5],
}),
};
// Metrics collection middleware
export function metricsMiddleware() {
return (req: Request, res: Response, next: NextFunction) => {
const start = Date.now();
// Increment active connections
systemMetrics.activeConnections.inc();
res.on('finish', () => {
const duration = (Date.now() - start) / 1000;
// Record HTTP request metrics
businessMetrics.httpRequestsTotal
.labels(req.method, req.route?.path || req.path, res.statusCode.toString())
.inc();
businessMetrics.httpRequestDuration
.labels(req.method, req.route?.path || req.path)
.observe(duration);
// Decrement active connections
systemMetrics.activeConnections.dec();
});
next();
};
}
// Export metrics for Prometheus
export function getMetrics() {
return register.metrics();
}
// System metrics collection
setInterval(() => {
const memUsage = process.memoryUsage();
systemMetrics.memoryUsage.labels('heap').set(memUsage.heapUsed);
systemMetrics.memoryUsage.labels('external').set(memUsage.external);
systemMetrics.memoryUsage.labels('array_buffers').set(memUsage.arrayBuffers);
}, 5000);
class IntelligentAlertingSystem:
def __init__(self):
self.anomaly_detector = AnomalyDetector()
self.escalation_manager = EscalationManager()
self.correlation_engine = AlertCorrelationEngine()
async def setup_intelligent_alerting(self,
monitoring_config: MonitoringConfiguration) -> AlertingSetup:
"""Configure intelligent alerting with anomaly detection."""
# Set up anomaly detection
anomaly_config = self.anomaly_detector.configure_detection(
monitoring_config.metrics,
sensitivity_level=monitoring_config.sensitivity,
learning_period=monitoring_config.learning_period
)
# Configure escalation policies
escalation_policies = self.escalation_manager.create_policies(
monitoring_config.severity_levels,
monitoring_config.notification_channels
)
# Set up alert correlation
correlation_rules = self.correlation_engine.define_correlation_rules(
monitoring_config.service_dependencies,
monitoring_config.infrastructure_topology
)
return AlertingSetup(
anomaly_detection=anomaly_config,
escalation_policies=escalation_policies,
correlation_rules=correlation_rules,
suppression_rules=self._configure_suppression_rules(),
enrichment_rules=self._configure_enrichment_rules()
)
// AI-powered performance optimization
export class PerformanceOptimizer {
private performanceData: PerformanceMetrics[] = [];
private model: PerformanceModel;
constructor() {
this.model = new PerformanceModel();
}
async collectPerformanceMetrics(): Promise<void> {
// Collect comprehensive performance metrics
const metrics = await this.gatherMetrics();
this.performanceData.push(metrics);
// Keep only recent data for training
if (this.performanceData.length > 1000) {
this.performanceData = this.performanceData.slice(-1000);
}
}
async predictPerformanceIssues(): Promise<PerformancePrediction[]> {
// Use trained model to predict potential issues
const features = this.extractFeatures(this.performanceData);
const predictions = await this.model.predict(features);
return predictions.map((prediction, index) => ({
timestamp: Date.now() + (index * 60000), // Next hour predictions
issue_type: prediction.type,
confidence: prediction.confidence,
severity: prediction.severity,
recommended_actions: this.getRecommendedActions(prediction),
}));
}
async optimizeResourceAllocation(): Promise<ResourceOptimization> {
// Analyze current resource usage patterns
const usagePatterns = this.analyzeUsagePatterns();
// Generate optimization recommendations
return {
cpu_scaling: this.optimizeCPUAllocation(usagePatterns.cpu),
memory_scaling: this.optimizeMemoryAllocation(usagePatterns.memory),
database_scaling: this.optimizeDatabaseAllocation(usagePatterns.database),
cache_optimization: this.optimizeCacheConfiguration(usagePatterns.cache),
};
}
private getRecommendedActions(prediction: any): string[] {
const actions: string[] = [];
switch (prediction.type) {
case 'high_cpu':
actions.push('Scale up CPU resources');
actions.push('Optimize CPU-intensive operations');
break;
case 'memory_leak':
actions.push('Investigate memory usage patterns');
actions.push('Consider memory profiling');
break;
case 'slow_database':
actions.push('Check database query performance');
actions.push('Optimize database indexes');
break;
case 'high_response_time':
actions.push('Analyze request handling bottlenecks');
actions.push('Implement request batching');
break;
}
return actions;
}
}
// Advanced distributed tracing with correlation
export class DistributedTracing {
private tracer: Tracer;
constructor() {
this.tracer = trace.getTracer('distributed-tracing');
}
async traceWorkflow(workflowName: string, steps: WorkflowStep[]): Promise<void> {
const mainSpan = this.tracer.startSpan(`workflow.${workflowName}`, {
attributes: {
'workflow.name': workflowName,
'workflow.steps_count': steps.length.toString(),
},
});
try {
for (const step of steps) {
const stepSpan = this.tracer.startSpan(`step.${step.name}`, {
parent: mainSpan,
attributes: {
'step.name': step.name,
'step.type': step.type,
'step.service': step.service,
},
});
try {
await this.executeStep(step);
stepSpan.setAttributes({
'step.status': 'success',
'step.duration': stepSpan.duration[0].toString(),
});
} catch (error) {
stepSpan.recordException(error as Error);
stepSpan.setAttributes({
'step.status': 'error',
'step.error': (error as Error).message,
});
throw error;
} finally {
stepSpan.end();
}
}
} finally {
mainSpan.end();
}
}
private async executeStep(step: WorkflowStep): Promise<void> {
// Add custom baggage for context propagation
const baggage = propagate.getActiveBaggage();
if (!baggage) {
propagate.setBaggage(
Baggage.fromEntries([
['workflow.id', crypto.randomUUID()],
['correlation.id', crypto.randomUUID()],
['user.id', step.context?.userId || 'anonymous'],
])
);
}
// Execute the step with proper context
await step.execute();
}
// Correlation analysis for distributed systems
async analyzeCorrelations(traceData: TraceData[]): Promise<CorrelationAnalysis> {
const correlations = new Map<string, CorrelationResult>();
// Analyze trace patterns
for (const trace of traceData) {
const correlationId = trace.attributes['correlation.id'];
if (correlationId) {
const existing = correlations.get(correlationId) || {
correlationId,
spans: [],
services: new Set(),
errors: [],
totalDuration: 0,
};
existing.spans.push(trace);
existing.services.add(trace.attributes['service.name']);
if (trace.attributes['error']) {
existing.errors.push(trace);
}
existing.totalDuration += trace.duration || 0;
correlations.set(correlationId, existing);
}
}
return {
totalCorrelations: correlations.size,
correlationResults: Array.from(correlations.values()),
errorRate: this.calculateErrorRate(correlations),
averageDuration: this.calculateAverageDuration(correlations),
};
}
}
create_metric(name, type, labels) - Create custom metricrecord_event(event_name, attributes) - Record business eventcreate_span(name, parent_span) - Create tracing spanset_alert(condition, severity, channels) - Configure alertcreate_dashboard(metrics, visualization) - Create monitoring dashboardget_latest_monitoring_documentation() - Official monitoring docs via Context7analyze_observability_patterns() - Observability best practices via Context7optimize_monitoring_stack() - Monitoring optimization via Context7moai-baas-foundation (Enterprise BaaS monitoring)moai-essentials-perf (Performance optimization)moai-security-api (Security monitoring)moai-foundation-trust (Compliance monitoring)moai-domain-backend (Backend application monitoring)moai-domain-frontend (Frontend performance monitoring)moai-domain-devops (DevOps and infrastructure monitoring)moai-security-owasp (Security threat monitoring)End of Skill | Updated 2025-11-13
End of Enterprise Application Monitoring Expert v4.0.0