node os monitor
1.0.0
Un moniteur très simple pour le os intégré, les modules fs dans Node.js.
Vous permet d'observer certains paramètres du système d'exploitation, tels que la mémoire libre disponible, la moyenne de chargement ou l'espace disque libre.
Libéré sous la licence du MIT.
Pour installer la dernière version stable de os-monitor :
npm install os-monitor
Si vous utilisez une ancienne version de Node.js (plus ancien que v18.15.x), vous pourriez avoir besoin de la version héritée (1.x) d' os-monitor ; Il prend en charge Node.js à V0.10.x:
npm install os-monitor@legacy
const { Monitor } = require ( "os-monitor" ) ;
const monitor = new Monitor ( ) ;
// basic usage
monitor . start ( ) ;
// more advanced usage with configs.
monitor . start ( { delay : 3000 // interval in ms between monitor cycles
, freemem : 1000000000 // freemem under which event 'freemem' is triggered
, uptime : 1000000 // number of secs over which event 'uptime' is triggered
, diskfree : {
'/' : 100000 , // number of free blocks under which event 'diskfree' is triggered
'/home' : 100000
}
, critical1 : 0.7 // loadavg1 over which event 'loadavg1' is triggered
, critical5 : 0.7 // loadavg5 over which event 'loadavg5' is triggered
, critical15 : 0.7 // loadavg15 over which event 'loadavg15' is triggered
, silent : false // set true to mute event 'monitor'
, stream : false // set true to enable the monitor as a Readable Stream
, immediate : false // set true to execute a monitor cycle at start()
} ) ;
// define handler that will always fire every cycle
monitor . on ( 'monitor' , ( event ) => {
console . log ( event . type , 'This event always happens on each monitor cycle!' ) ;
} ) ;
// define handler for a too high 1-minute load average
monitor . on ( 'loadavg1' , ( event ) => {
console . log ( event . type , 'Load average is exceptionally high!' ) ;
} ) ;
// define handler for a too low free memory
monitor . on ( 'freemem' , ( event ) => {
console . log ( event . type , 'Free memory is very low!' ) ;
} ) ;
// define a throttled handler
monitor . throttle ( 'loadavg5' , ( event ) => {
// whatever is done here will not happen
// more than once every 5 minutes(300000 ms)
} , monitor . minutes ( 5 ) ) ;
// change config while monitor is running
monitor . config ( {
freemem : 0.3 // alarm when 30% or less free memory available
} ) ;
// stop monitor
monitor . stop ( ) ;
// check whether monitor is running or not
monitor . isRunning ( ) ; // -> true / false
// use as readable stream
monitor . start ( { stream : true } ) . pipe ( process . stdout ) ;Retard en millisecondes entre chaque cycle de moniteur. Par défaut: 3000
Quantité de mémoire en octets dans lesquels l'événement «Freemem» est déclenché. Peut également être un pourcentage de mémoire totale. Par défaut: 0
Nombre de secondes sur quel événement «de disponibilité» est déclenché. Par défaut: indéfini
Objet contenant des valeurs de blocs libres, pour les chemins de système de fichiers donnés, sous quel événement «diskfree» est déclenché. Prise en charge de Node.js v18.15.x et ultérieurement. (Réf.) Par défaut: {}
Valeur d'une moyenne de chargement de 1 minute sur laquelle l'événement «Loadavg1» est déclenché. Par défaut: os.cpus (). Longueur
(Un concept spécifique à l'Unix, la moyenne de charge est une mesure de l'activité du système, calculée par le système d'exploitation et exprimée en nombre fractionnaire. En règle générale, la moyenne de charge devrait idéalement être inférieure au nombre de processeurs logiques dans le système. Ref.: Http://nodejs.org/api/os.html#os_os_loadavg)
Valeur de 5 minutes moyenne de chargement sur le déclenchement de l'événement «LOADAVG5». Par défaut: os.cpus (). Longueur
Valeur de 15 minutes moyenne de chargement sur quel événement «LOADAVG15» est déclenché. Par défaut: os.cpus (). Longueur
Définir le «moniteur» de l'événement MUTE. Par défaut: faux
Définissez True pour activer le moniteur en tant que flux lisible. Par défaut: faux
Définissez True pour exécuter un cycle de moniteur sur start (). Par défaut: faux
La propriété monitor.version contient la chaîne de version os-monitor .
Démarre le moniteur. Accepte un objet d'options facultatifs.
Arrête le moniteur.
Vérifie si le moniteur est en cours d'exécution ou non; Renvoie un booléen.
Accepte un objet d'options facultatifs et met à jour la configuration du moniteur. Renvoie toujours les options de configuration du moniteur.
Réinitialise la configuration du moniteur à ses valeurs par défaut.
Ajoute un écouteur pour le type d'événement spécifié. Les événements pris en charge sont: «Monitor», «Uptime», «Freemem», «Diskfree», «Loadavg1», «Loadavg5», «Loadavg15», «Démarrer», «Stop», «Config», «réinitialiser», «Détroyer».
Ajoute un écouteur unique pour le type d'événement spécifié. Cet auditeur n'est invoqué que la prochaine fois que l'événement sera licencié, après quoi il est supprimé.
Ajoute un écouteur étranglé. L'auditeur étranglé ne sera pas exécuté plus d'une fois chaque retard de millisecondes.
Supprime un écouteur étranglé précédemment ajouté en utilisant .throttle() . handler doit être la fonction d'origine.
Renvoie une promesse qui se résout avec un objet d'événement lorsque eventType est déclenché.
S'arrête et désactive en permanence le moniteur.
Méthodes de commodité pour obtenir la bonne quantité de millisecondes.
monitor . seconds ( 10 ) ; // -> 10000 ms
monitor . minutes ( 5 ) ; // -> 300000 ms
monitor . hours ( 1 ) ; // -> 3600000 ms
monitor . days ( 1 ) ; // -> 86400000 ms
// start with a delay of 5000 ms
monitor . start ( { delay : monitor . seconds ( 5 ) } ) ;Méthode de commodité pour obtenir la bonne quantité de blocs du système de fichiers.
monitor . blocks ( 100000000 , 4096 ) ; // -> 24415 blocks
// start by observing file system path `/filesystem`
monitor . start ( {
diskfree : {
'/filesystem' : monitor . blocks ( 100000000 , 4096 )
}
} ) ; Il existe des informations utiles dans l'objet de l'événement fourni:
{
"type": "monitor", // event type
"loadavg": [
0.4599609375,
0.53076171875,
0.4990234375
], // load average values for 1, 5, 15 minutes
"uptime": 1614056, // os uptime in seconds
"freemem": 241262592, // free memory available in bytes
"totalmem": 2147483648, // total memory available in bytes
"diskfree": {
"/": 25786328,
"/home": 12786329
}, // available blocks per file system path, if any config was passed for 'diskfree' event
"timestamp": 1394766898 // UNIX Timestamp
}
Tous les événements pris en charge sont: «Monitor», «Uptime», «Freemem», «Diskfree», «Loadavg1», «Loadavg5», «Loadavg15», «Démarrer», «Stop», «Config», «réinitialiser», «Détroyer». Notez que os-monitor est une instance de EventEmitter .
Événements API Docs: nodejs.org/api/events
os-monitor peut également être utilisé comme flux lisible.
monitor.start({ stream: true });
// write to STDOUT
monitor.pipe(process.stdout);
// write to a file
let fs = require('fs'),
logFile = fs.createWriteStream('/tmp/log.txt', {flags: 'a'});
monitor.pipe(logFile);
os-monitor prend en charge la promesse, Async / Await: Utilisation .when(eventType) Renvoie une promesse.
monitor.when('freemem').then(event => {
// ...
});
async function callback() {
let event = await monitor.when('uptime');
// ...
}
Besoin d'instances de moniteur simultanées? Plusieurs instances peuvent être créées à l'aide de la classe Monitor :
const { Monitor } = require('os-monitor');
let monitor1 = new Monitor();
let monitor2 = new Monitor();
let monitor3 = new Monitor();
os-monitor est libéré sous la licence du MIT.
100% gratuit: os-monitor peut être utilisé librement dans des projets propriétaires et open source.
L'attribution est requise: vous devez conserver le nom de l'auteur et les informations de licence dans tout code distribué. Ces éléments n'ont pas besoin d'être orientés vers les utilisateurs et peuvent rester dans la base de code.
