Nowoczesne systemy rozproszone wymagają wyrafinowanych rozwiązań monitorowania i obserwowalności. Asystenci AI do kodowania wyróżniają się w implementacji OpenTelemetry, tworzeniu dashboardów, pisaniu zapytań i konfigurowaniu alertowania - przekształcając obserwowalność z ciężaru w strategiczną przewagę.
Tradycyjne podejścia do monitorowania mają problemy z:
Asystenci AI pomagają poprzez:
@codebase "Skonfiguruj OpenTelemetry dla naszych mikroserwisów Node.js:- Automatyczna instrumentacja dla Express, MongoDB, Redis- Niestandardowe spany dla operacji biznesowych- Propagacja kontekstu śledzenia między serwisami- Metryki dla SLI (opóźnienie, wskaźnik błędów, przepustowość)- Strukturalne logowanie z korelacją śladów- Export zarówno do Jaeger, jak i Prometheus"claude "Zaimplementuj kompleksową konfigurację OpenTelemetry dla naszych serwisów"
# Claude:# 1. Zainstaluje niezbędne pakiety OTel# 2. Utworzy moduły instrumentacji# 3. Skonfiguruje kolektory i eksportery# 4. Skonfiguruje propagację kontekstu# 5. Doda niestandardową instrumentację// Kompleksowa konfiguracja OTel wygenerowana przez AIimport { 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-trace-otlp-grpc';import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-grpc';import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
// Inicjalizacja OpenTelemetryconst sdk = new NodeSDK({ resource: new Resource({ [SemanticResourceAttributes.SERVICE_NAME]: process.env.SERVICE_NAME, [SemanticResourceAttributes.SERVICE_VERSION]: process.env.SERVICE_VERSION, [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: process.env.NODE_ENV, }),
traceExporter: new OTLPTraceExporter({ url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT, }),
metricReader: new PeriodicExportingMetricReader({ exporter: new OTLPMetricExporter({ url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT, }), exportIntervalMillis: 30000, }),
instrumentations: [ getNodeAutoInstrumentations({ '@opentelemetry/instrumentation-fs': { enabled: false, // Zbyt głośne }, }), ],});
// Niestandardowa instrumentacja biznesowaexport function createBusinessSpan(operation: string) { const tracer = trace.getTracer('business-operations'); return tracer.startSpan(operation, { attributes: { 'business.operation': operation, 'business.user_id': getCurrentUserId(), 'business.tenant': getTenantId(), }, });}
// Strukturalne logowanie z korelacją śladówexport function getLogger(component: string) { return { info: (message: string, data?: any) => { const span = trace.getActiveSpan(); const traceId = span?.spanContext().traceId;
console.log(JSON.stringify({ timestamp: new Date().toISOString(), level: 'info', component, message, traceId, ...data, })); }, // Podobnie dla error, warn, debug };}
Prompt AI dla konfiguracji stosu
"Stwórz kompletny stos monitorowania z:- OpenTelemetry Collector z odpowiednią konfiguracją- Prometheus dla metryk z politykami retencji- Loki dla logów z backendem S3- Tempo dla śladów z możliwościami wyszukiwania- Grafana z pre-skonfigurowanymi źródłami danych- Odpowiednim networkingiem i persistence"AI wygeneruje kompleksowy docker-compose.yml ze wszystkimi serwisami odpowiednio skonfigurowanymi i połączonymi.
@prometheus @grafana "Stwórz dashboard zdrowia serwisu pokazujący:- Request rate, error rate, duration (metryki RED)- Opóźnienia P50, P95, P99 według endpointu- Wskaźnik spalania budżetu błędów- Aktywne alerty i ich status- Wykorzystanie zasobów (CPU, pamięć, połączenia)- Status zdrowia zależnościUżyj najlepszych praktyk PromQL i uczyń go responsywnym"Zdefiniuj kluczowe metryki
"Zidentyfikuj nasze kluczowe metryki biznesowe:- Zaangażowanie użytkowników (DAU, MAU, retencja)- Wskaźniki sukcesu transakcji- Wpływ błędów na przychody- Wskaźniki adopcji funkcji"Wygeneruj zapytania
"Napisz zapytania PromQL dla tych metryk biznesowych,korelując metryki techniczne z wpływem biznesowym"Stwórz wizualizacje
"Zaprojektuj panele Grafana, które opowiadają historię,z możliwościami drill-down od metryk biznesowych do technicznych"// Middleware propagacji śledzenia wygenerowany przez AIexport const traceMiddleware = (req, res, next) => { const tracer = trace.getTracer('http-middleware'); const propagator = new W3CTraceContextPropagator();
// Wyodrębnij kontekst z przychodzącego żądania const parentContext = propagator.extract( context.active(), req.headers, defaultTextMapGetter );
// Rozpocznij nowy span jako dziecko wyodrębnionego kontekstu const span = tracer.startSpan( `${req.method} ${req.route.path}`, { kind: SpanKind.SERVER, attributes: { 'http.method': req.method, 'http.url': req.url, 'http.target': req.route.path, 'http.host': req.hostname, 'http.scheme': req.protocol, 'user.id': req.user?.id, }, }, parentContext );
// Wstrzyknij kontekst dla serwisów downstream const headers = {}; propagator.inject( trace.setSpan(context.active(), span), headers, defaultTextMapSetter ); req.traceHeaders = headers;
// Zakończ span na odpowiedzi res.on('finish', () => { span.setAttributes({ 'http.status_code': res.statusCode, 'http.response.size': res.get('content-length'), }); span.setStatus({ code: res.statusCode >= 400 ? SpanStatusCode.ERROR : SpanStatusCode.OK, }); span.end(); });
next();};// Niestandardowa instrumentacja wygenerowana przez AIexport class PaymentService { private tracer = trace.getTracer('payment-service'); private meter = metrics.getMeter('payment-service'); private paymentCounter = this.meter.createCounter('payments_total'); private paymentDuration = this.meter.createHistogram('payment_duration_ms');
async processPayment(order: Order): Promise<PaymentResult> { const span = this.tracer.startSpan('process_payment', { attributes: { 'payment.amount': order.amount, 'payment.currency': order.currency, 'payment.method': order.paymentMethod, 'order.id': order.id, }, });
const startTime = Date.now();
try { // Walidacja płatności const validationSpan = this.tracer.startSpan( 'validate_payment', { parent: span } ); await this.validatePayment(order); validationSpan.end();
// Przetwarzanie z gateway const gatewaySpan = this.tracer.startSpan( 'gateway_transaction', { parent: span } ); const result = await this.callPaymentGateway(order); gatewaySpan.setAttributes({ 'gateway.response_code': result.code, 'gateway.transaction_id': result.transactionId, }); gatewaySpan.end();
// Rejestruj metryki this.paymentCounter.add(1, { status: 'success', method: order.paymentMethod, });
return result; } catch (error) { span.recordException(error); span.setStatus({ code: SpanStatusCode.ERROR, message: error.message, });
this.paymentCounter.add(1, { status: 'failure', method: order.paymentMethod, error_type: error.constructor.name, });
throw error; } finally { const duration = Date.now() - startTime; this.paymentDuration.record(duration, { method: order.paymentMethod, }); span.end(); } }}# Konfiguracja Loki wygenerowana przez AIauth_enabled: false
server: http_listen_port: 3100 grpc_listen_port: 9096
ingester: wal: enabled: true dir: /loki/wal lifecycler: address: 127.0.0.1 ring: kvstore: store: inmemory replication_factor: 1
schema_config: configs: - from: 2023-01-01 store: boltdb-shipper object_store: s3 schema: v11 index: prefix: index_ period: 24h
storage_config: aws: s3: s3://access_key:secret_key@endpoint/bucket s3forcepathstyle: true boltdb_shipper: active_index_directory: /loki/boltdb-shipper-active cache_location: /loki/boltdb-shipper-cache shared_store: s3
limits_config: ingestion_rate_mb: 10 ingestion_burst_size_mb: 20 max_streams_per_user: 10000 max_global_streams_per_user: 10000
compactor: working_directory: /loki/compactor shared_store: s3 compaction_interval: 10m# Reguły alertów Prometheus wygenerowane przez AIgroups: - name: service_health interval: 30s rules: - alert: HighErrorRate expr: | ( sum(rate(http_requests_total{status=~"5.."}[5m])) by (service) / sum(rate(http_requests_total[5m])) by (service) ) > 0.05 for: 5m labels: severity: critical team: platform annotations: summary: "Wysoki wskaźnik błędów na {{ $labels.service }}" description: "{{ $labels.service }} ma {{ $value | humanizePercentage }} wskaźnik błędów" runbook_url: "https://wiki.example.com/runbooks/high-error-rate"
- alert: SLOBurnRateTooHigh expr: | ( 1 - ( sum(rate(http_requests_total{status!~"5.."}[5m])) by (service) / sum(rate(http_requests_total[5m])) by (service) ) ) > (1 - 0.999) * 14.4 for: 5m labels: severity: warning team: platform annotations: summary: "Wskaźnik spalania SLO zbyt wysoki dla {{ $labels.service }}" description: "W tym tempie {{ $labels.service }} wyczerpie budżet błędów w < 1 dzień"
- alert: PodMemoryUsageHigh expr: | ( container_memory_working_set_bytes{pod!=""} / container_spec_memory_limit_bytes{pod!=""} > 0 ) > 0.9 for: 5m labels: severity: warning annotations: summary: "Pod {{ $labels.pod }} wykorzystanie pamięci > 90%" description: "Rozważ zwiększenie limitów pamięci lub optymalizację aplikacji"# Konfiguracja AlertManager wygenerowana przez AIglobal: resolve_timeout: 5m slack_api_url: '{{ SLACK_API_URL }}'
route: group_by: ['alertname', 'cluster', 'service'] group_wait: 10s group_interval: 10s repeat_interval: 12h receiver: 'default'
routes: # Krytyczne alerty idą do PagerDuty - match: severity: critical receiver: pagerduty continue: true
# Ostrzeżenia tylko w godzinach pracy - match: severity: warning receiver: slack-warnings active_time_intervals: - business-hours
# Routing specyficzny dla zespołu - match_re: service: ^(payment|billing).* receiver: finance-team
# Alerty środowiska deweloperskiego - match: environment: development receiver: dev-null
receivers: - name: 'default' slack_configs: - channel: '#alerts' title: 'Alert: {{ .GroupLabels.alertname }}' text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'
- name: 'pagerduty' pagerduty_configs: - service_key: '{{ PAGERDUTY_SERVICE_KEY }}' description: '{{ .GroupLabels.alertname }}: {{ .CommonAnnotations.summary }}'
- name: 'dev-null' # Cicho odrzuć
inhibit_rules: - source_match: severity: 'critical' target_match: severity: 'warning' equal: ['alertname', 'service']"Stwórz dashboard Grafana, który koreluje:- Ślady pokazujące wolne żądania- Logi z tych konkretnych ID śledzenia- Metryki pokazujące stan systemu podczas incydentu- Powiązane alerty, które zostały wywołaneUżyj widoku Explore Grafana z integracją Loki/Tempo"Zidentyfikuj anomalię
# Zapytanie wykrywania anomalii wygenerowane przez AI( rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_count[5m])) >( avg_over_time( rate(http_request_duration_seconds_sum[5m])[1h:5m] / rate(http_request_duration_seconds_count[5m])[1h:5m] ) * 2)Analiza śladów
"Dla ID śledzenia X, przeanalizuj:- Który span trwał najdłużej- Wszelkie błędy w spanach dziecięcych- Wzorce zapytań do bazy danych- Wywołania serwisów zewnętrznych"Badanie logów
# Zapytanie LogQL wygenerowane przez AI{service="api"}| json| trace_id="abc123"| line_format "{{.timestamp}} [{{.level}}] {{.message}}"| pattern "<_> error=<error> <_>"Korelacja metryk
"Pokaż mi metryki CPU, pamięci i puli połączeńdla serwisu podczas okna incydentu"@tempo @grafana "Stwórz zapytania do znalezienia:- Najwolniejszych endpointów według opóźnienia P95- Najczęstszych zapytań do bazy danych- Serwisów z najwyższymi wskaźnikami błędów- Śladów z największą liczbą spanów (złożoność)- Wskaźników trafień cache według serwisu"
Automatyczna analiza wydajności
// Analizator wydajności wygenerowany przez AIexport class PerformanceAnalyzer { async analyzeTraces(timeRange: TimeRange) { const slowTraces = await this.tempo.search({ query: 'duration > 1s', limit: 100, start: timeRange.start, end: timeRange.end, });
const patterns = this.identifyPatterns(slowTraces); const recommendations = this.generateRecommendations(patterns);
return { bottlenecks: patterns.bottlenecks, recommendations, estimatedImpact: this.calculateImpact(patterns), }; }
private identifyPatterns(traces: Trace[]) { // Grupuj według operacji i analizuj const operationStats = traces.reduce((acc, trace) => { trace.spans.forEach(span => { if (!acc[span.operation]) { acc[span.operation] = { count: 0, totalDuration: 0, errors: 0, }; } acc[span.operation].count++; acc[span.operation].totalDuration += span.duration; if (span.status === 'error') acc[span.operation].errors++; }); return acc; }, {});
// Znajdź wąskie gardła const bottlenecks = Object.entries(operationStats) .filter(([_, stats]) => stats.totalDuration / stats.count > 100) .sort((a, b) => b[1].totalDuration - a[1].totalDuration) .slice(0, 5);
return { operationStats, bottlenecks }; }}# Polisy retencji wygenerowane przez AIretention_policies: metrics: - selector: '{__name__=~"up|scrape_.*"}' retention: 30d # Metryki infrastruktury - selector: '{__name__=~"http_.*"}' retention: 90d # Metryki aplikacji - selector: '{__name__=~"business_.*"}' retention: 400d # Metryki biznesowe
logs: - level: debug retention: 1d - level: info retention: 7d - level: warning retention: 30d - level: error retention: 90d
traces: - sampling_rate: 0.1 # 10% dla normalnego ruchu - error_sampling: 1.0 # 100% dla błędów - slow_sampling: 0.5 # 50% dla wolnych żądań"Przeanalizuj nasz stos obserwowalności i zasugeruj optymalizacje:- Redukcja kardynalności dla Prometheus- Parsowanie logów w celu zmniejszenia storage- Strategie samplingowania śladów- Optymalizacja zapytań dashboardu- Deduplikacja alertów"{ "mcpServers": { "sentry": { "command": "npx", "args": ["-y", "sentry-mcp"], "env": { "SENTRY_AUTH_TOKEN": "${SENTRY_AUTH_TOKEN}", "SENTRY_ORG": "your-org" } } }}Użycie:
"Używając Sentry MCP:- Pobierz trendy błędów z ostatnich 24h- Znajdź najczęstsze błędy- Przeanalizuj wpływ błędów według liczby użytkowników- Stwórz zgłoszenia GitHub dla krytycznych błędów"{ "mcpServers": { "grafana": { "command": "npx", "args": ["-y", "@leval/mcp-grafana"], "env": { "GRAFANA_URL": "https://grafana.example.com", "GRAFANA_API_KEY": "${GRAFANA_API_KEY}" } } }}Kontrola wersji wszystkiego
Automatyzuj wdrożenie
# CI/CD dla obserwowalności wygenerowane przez AIdeploy-monitoring: steps: - name: Walidacja konfiguracji run: | promtool check rules alerts/*.yml grafana-validator dashboards/*.json
- name: Wdróż reguły Prometheus run: | kubectl apply -f k8s/prometheus-rules.yaml
- name: Importuj dashboardy run: | for dashboard in dashboards/*.json; do curl -X POST -H "Authorization: Bearer $GRAFANA_TOKEN" \ -H "Content-Type: application/json" \ -d @$dashboard \ https://grafana.example.com/api/dashboards/db doneTestuj swoją obserwowalność
"Stwórz testy dla naszego monitorowania:- Zweryfikuj, że alerty są poprawnie wywoływane- Testuj, że zapytania dashboardu zwracają dane- Waliduj propagację śladów- Sprawdź reguły parsowania logów"Prywatność danych
Kontrola dostępu
"Przeanalizuj metryki Prometheus pod kątem wysokiej kardynalności:- Znajdź metryki z największą liczbą unikalnych kombinacji etykiet- Zasugeruj strategie redukcji etykiet- Zaimplementuj reguły nagrywania dla agregacji- Dodaj egzekwowanie kardynalności""Debuguj problemy propagacji śladów:- Zweryfikuj, że nagłówki kontekstu są przekazywane- Sprawdź decyzje samplingowania- Waliduj konfigurację eksportera- Testuj z wymuszonym samplingowaniem""Napraw zalewanie alertami:- Zaimplementuj odpowiednie grupowanie- Dodaj reguły inhibicji- Użyj zależności alertów- Dostosuj progi na podstawie historii""Zaimplementuj wykrywanie anomalii oparte na ML:- Trenuj modele na historycznych metrykach- Automatycznie wykrywaj nietypowe wzorce- Przewiduj potrzeby pojemnościowe- Automatycznie generuj raporty incydentów"Połączenie pomocy AI i nowoczesnych narzędzi obserwowalności sprawia, że kompleksowe monitorowanie jest dostępne dla zespołów każdej wielkości. Zacznij od małego, iteruj szybko i pozwól AI obsługiwać złożoność, podczas gdy Ty skupiasz się na wglądach.