Verbessern Sie Ihre Node.js-Überwachung mit diesen wesentlichen Metriken

Als Node.js-Entwickler ist es von entscheidender Bedeutung, dass Ihre Anwendungen reibungslos laufen. Aber woher wissen Sie, was unter der Haube passiert? Hier kommen Metriken ins Spiel. In diesem Artikel untersuchen wir einige wichtige Metriken, die Ihnen helfen, Ihre Node.js-Anwendungen wie ein Profi zu überwachen und zu optimieren.

Um mehr zu erfahren, können Sie sich den vollständigen Blogbeitrag ansehen.

1. CPU-Auslastung

? Halten Sie das Gehirn Ihrer App gesund.

Überwachen Sie die CPU-Auslastung, um sicherzustellen, dass Ihre Anwendung sich nicht selbst überlastet.

const os = require('os');

function getCPUUsage() {
  const cpus = os.cpus();
  const totalUsage = cpus.reduce((acc, cpu) => acc + cpu.times.user + cpu.times.system, 0);
  const totalIdle = cpus.reduce((acc, cpu) => acc + cpu.times.idle, 0);
  return totalUsage / (totalUsage + totalIdle) * 100;
}

2. Speichernutzung

? Lassen Sie Ihre App nicht zum Speicherfresser werden.

Verfolgen Sie die Speichernutzung, um Lecks zu verhindern und die Leistung zu optimieren.

const v8 = require('v8');

function getMemoryUsage() {
  const memoryUsage = process.memoryUsage();
  const heapStats = v8.getHeapStatistics();
  return {
    rss: memoryUsage.rss,
    heapTotal: memoryUsage.heapTotal,
    heapUsed: memoryUsage.heapUsed,
    external: memoryUsage.external,
    heapSizeLimit: heapStats.heap_size_limit
  };
}

3. Verzögerung der Ereignisschleife

⏱️ Halten Sie Ihre App reaktionsfähig.

Überwachen Sie die Verzögerung der Ereignisschleife, um eine reibungslose Ausführung asynchroner Vorgänge sicherzustellen.

const lag = require('event-loop-lag');

const lagMonitor = lag(1000);

function getEventLoopLag() {
  return lagMonitor();
}

4. HTTP-Anfragerate

? Verfolgen Sie die Beliebtheit Ihrer App.

Überwachen Sie die Rate eingehender HTTP-Anfragen, um den Datenverkehr zu messen und die Skalierung zu planen.

const http = require('http');

let requestCount = 0;

http.createServer((req, res) => {
  requestCount++;
  // Your server logic here
}).listen(3000);

function getRequestRate() {
  const rate = requestCount;
  requestCount = 0;
  return rate;
}

setInterval(() => {
  console.log(`Request rate: ${getRequestRate()} requests/second`);
}, 1000);

5. Datenbankverbindungspool

?‍♂️ Halten Sie Ihre Datenbankverbindungen unter Kontrolle.

Überwachen Sie Ihren Verbindungspool, um eine effiziente Ressourcennutzung sicherzustellen.

const mysql = require('mysql');

const pool = mysql.createPool({
  connectionLimit: 10,
  host: 'localhost',
  user: 'your_username',
  password: 'your_password',
  database: 'your_database'
});

function getConnectionPoolStats() {
  return {
    total: pool._allConnections.length,
    free: pool._freeConnections.length,
    queued: pool._connectionQueue.length
  };
}

6. Garbage-Collection-Metriken

?️ Halten Sie den Speicher Ihrer App sauber.

Überwachen Sie die Speicherbereinigung, um die Speicherverwaltung zu optimieren.

javascriptCopyconst v8 = require('v8');

const gcStats = v8.getHeapStatistics();

function getGCMetrics() {
  return {
    totalHeapSize: gcStats.total_heap_size,
    usedHeapSize: gcStats.used_heap_size,
    heapSizeLimit: gcStats.heap_size_limit
  };
}

7. Aktive Handles und Anfragen

? Verfolgen Sie den laufenden Betrieb.

Überwachen Sie aktive Handles und Anfragen, um eine ordnungsgemäße Ressourcenverwaltung sicherzustellen.

javascriptCopyfunction getActiveHandlesAndRequests() {
  return {
    activeHandles: process._getActiveHandles().length,
    activeRequests: process._getActiveRequests().length
  };
}

8. Fehlerrate

❌ Bleiben Sie stets auf dem Laufenden.

Überwachen Sie die Fehlerrate Ihrer Anwendung, um Probleme schnell zu erkennen und zu lösen.

javascriptCopylet errorCount = 0;

process.on('uncaughtException', (error) => {
  errorCount++;
  // Log or handle the error
});

function getErrorRate() {
  const rate = errorCount;
  errorCount = 0;
  return rate;
}

setInterval(() => {
  console.log(`Error rate: ${getErrorRate()} errors/minute`);
}, 60000);

9. Reaktionszeit

⏱️ Sorgen Sie dafür, dass Ihre Benutzer zufrieden sind.

Überwachen Sie die Reaktionszeiten, um ein schnelles Benutzererlebnis zu gewährleisten.

javascriptCopyconst responseTime = require('response-time');
const express = require('express');

const app = express();

app.use(responseTime((req, res, time) => {
  console.log(`${req.method} ${req.url} - Response time: ${time}ms`);
}));

// Your routes here

10. Abhängigkeiten von Diensten Dritter

? Lassen Sie sich nicht von externen Diensten ausbremsen.

Überwachen Sie die Leistung von Drittanbieterdiensten, von denen Ihre App abhängt.

javascriptCopyconst axios = require('axios');

async function checkExternalService(url) {
  const start = Date.now();
  try {
    await axios.get(url);
    const duration = Date.now() - start;
    console.log(`External service ${url} response time: ${duration}ms`);
  } catch (error) {
    console.error(`Error checking external service ${url}: ${error.message}`);
  }
}

// Check external services periodically
setInterval(() => {
  checkExternalService('https://api.example.com');
}, 60000);

Bonus-Tipp: Verwenden Sie ein Überwachungstool

?️ Optimieren Sie Ihre Überwachung! Erwägen Sie den Einsatz eines speziellen Überwachungstools, um die Metrikerfassung zu automatisieren und tiefere Einblicke zu gewinnen.
Zu den beliebten Optionen gehören:

• Prometheus mit Grafana
• Neues Relikt
• Datadog
• AppDynamics

Diese Tools können sofort einsatzbereite Überwachungslösungen und schöne Dashboards bereitstellen, um die Leistung Ihrer Node.js-Anwendung zu visualisieren.
Durch die Integration dieser zusätzlichen Metriken und Tipps erhalten Sie einen noch umfassenderen Überblick über den Zustand und die Leistung Ihrer Node.js-Anwendung. Denken Sie daran, dass der Schlüssel zu einer effektiven Überwachung nicht nur im Sammeln von Daten liegt, sondern auch darin, die gewonnenen Erkenntnisse zu verstehen und darauf zu reagieren. Viel Spaß beim Beobachten!

Abschluss

Durch die Überwachung dieser wesentlichen Metriken erhalten Sie wertvolle Einblicke in die Leistung und den Zustand Ihrer Node.js-Anwendung. Denken Sie daran: Wissen ist Macht, und mit diesen Kennzahlen sind Sie bestens gerüstet, um Ihre App zu optimieren und für einen reibungslosen Betrieb zu sorgen.

Wenn Sie Hilfe bei der Überwachung Ihrer App benötigen, besuchen Sie https://alerty.ai, um mehr über die einfache Frontend-Überwachung zu erfahren.

Viel Spaß beim Überwachen und mögen Ihre Node.js-Apps immer die beste Leistung erbringen! ?

Das obige ist der detaillierte Inhalt vonVerbessern Sie Ihre Node.js-Überwachung mit diesen wesentlichen Metriken. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!