Überwachung von TypeScript-Anwendungen: Metriken und Alarme

Monitoring von TypeScript-Anwendungen: Metriken und Alarme

In der modernen Webentwicklung ist das Monitoring von TypeScript-Anwendungen kein Luxus, sondern eine Notwendigkeit. Ohne es riskieren Sie, erst von Benutzern von einem Ausfall zu erfahren. In diesem Artikel werden wir untersuchen, wie Sie effektives Monitoring für TypeScript-Projekte einrichten, welche Metriken Sie verfolgen und wie Sie Alarme konfigurieren, um Benachrichtigungen über Probleme zu erhalten, bevor sie kritisch werden.

Warum ist das Monitoring von TypeScript-Anwendungen so wichtig?

TypeScript, als Erweiterung von JavaScript, wird häufig für die Erstellung komplexer Unternehmenssysteme und serverseitiger Lösungen auf Node.js verwendet. Die dynamische Natur von JavaScript unter der Haube kann jedoch zu unerwarteten Laufzeitfehlern führen. Monitoring ermöglicht:

• Probleme frühzeitig erkennen — bevor sie sich auf Benutzer auswirken.
• Leistung analysieren — Engpässe im Code identifizieren.
• Ausfälle vorhersagen — basierend auf Metrik-Trends.
• Codequalität verbessern — verstehen, welche Module am "problematischsten" sind.

Wichtige Metriken für TypeScript-Anwendungen

Damit das Monitoring effektiv ist, müssen die richtigen Metriken gesammelt werden. Teilen wir sie in drei Hauptgruppen ein.

1. Technische Metriken (RED-Methode)

Der RED-Ansatz (Rate, Errors, Duration) eignet sich ideal für Microservices und APIs:

• Rate (Anfragehäufigkeit) — Anzahl der Anfragen pro Sekunde (RPS).
• Errors (Fehler) — Prozentsatz der Fehler (4xx, 5xx).
• Duration (Antwortzeit) — Bearbeitungszeit der Anfrage (p50, p95, p99).

Beispiel für das Sammeln von Metriken mit der Bibliothek prom-client:

import client from 'prom-client';import express from 'express';

const app = express();

// Metriken erstellenconst httpRequestDuration = new client.Histogram({  name: 'http_request_duration_seconds',  help: 'Duration of HTTP requests in seconds',  labelNames: ['method', 'route', 'status_code'],  buckets: [0.1, 0.5, 1, 2, 5]});

const httpRequestsTotal = new client.Counter({  name: 'http_requests_total',  help: 'Total number of HTTP requests',  labelNames: ['method', 'route', 'status_code']});

// Middleware zum Sammeln von Metrikenapp.use((req, res, next) => {  const end = httpRequestDuration.startTimer();  res.on('finish', () => {    const labels = { method: req.method, route: req.path, status_code: res.statusCode };    httpRequestsTotal.inc(labels);    end(labels);  });  next();});

// Endpoint für Prometheusapp.get('/metrics', async (req, res) => {  res.set('Content-Type', client.register.contentType);  res.end(await client.register.metrics());});

app.listen(3000, () => console.log('Server running on port 3000'));

2. Geschäftsmetriken

Diese Metriken spiegeln die Gesundheit des Geschäfts wider:

• Anzahl erfolgreicher Transaktionen.
• Durchschnittliche Warenkorbgröße (für E-Commerce).
• Antwortzeit der Datenbank.
• Anzahl aktiver Benutzer.

Beispiel für eine benutzerdefinierte Metrik zur Verfolgung von Bestellungen:

const ordersCreated = new client.Counter({  name: 'orders_created_total',  help: 'Total number of orders created',  labelNames: ['status']});

// Irgendwo im Codeexport function createOrder(data: OrderData): Order {  // Logik zur Bestellerstellung  ordersCreated.inc({ status: 'success' });  return order;}

3. Infrastrukturmetriken

Für Node.js/TypeScript-Anwendungen sind kritisch:

• Speichernutzung (heap, RSS).
• CPU-Auslastung.
• Anzahl offener Dateideskriptoren.
• Anzahl aktiver Verbindungen.
• Garbage Collection (GC).

Beispiel für das Sammeln von Speichermetriken:

                
                

                    

                        Blogs                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
Kotlin auf Maximum: Profilierung und Leistungsoptimierung
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Telegram-Bot auf Kotlin: Von Grund auf in einer Stunde erstellen
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Open Source Beitrag auf PHP: So startest du mit Contribute und bleibst dran
                                
                            
                                            
                

                
                

                    

                        Buchempfehlungen                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
Sicherheit von PHP-Anwendungen
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
PHP und Datenbanken: Ein praktischer Leitfaden
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Testen von Rust-Anwendungen: Von Unit-Tests bis zu Integrationsszenarien
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
API-Entwicklung mit Rust: Erstellung leistungsstarker Webdienste
                                
                            
                                            
                
            
    

  
Lesen Sie auch
  

                
                  
                 Magie von DispatchQueue.main.asyncAfter: Wie Verzögerung in Swift 3 funktioniert
      
                
                  
                 WebSocket in PHP: Erstellung von Echtzeitanwendungen von Grund auf
      
                
                  
                 Arbeiten mit WebAssembly und Rust: von A bis Z
      
                
                  
                 Listen in Kotlin klonen: Tiefe vs. flache Kopie
      
                
                  
                 Algorithmen und Datenstrukturen in Go: Ein praktischer Leitfaden