node os monitor

OS-monitor

Monitor yang sangat sederhana untuk modul os bawaan, fs di Node.js.

Memungkinkan Anda untuk mengamati beberapa parameter OS, seperti memori gratis yang tersedia, rata -rata beban atau ruang disk gratis.

Dirilis di bawah lisensi MIT.

Instalasi

Untuk menginstal versi stabil terbaru os-monitor :

 npm install os-monitor

Jika Anda menggunakan versi lama node.js (lebih tua dari v18.15.x), Anda mungkin memerlukan versi warisan (1.x) dari os-monitor ; Ini mendukung Node.js kembali ke v0.10.x:

 npm install os-monitor@legacy

Ringkasan

 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 ) ;

opsi konfigurasi

menunda

Keterlambatan dalam milidetik antara setiap siklus monitor. Default: 3000

Freemem

Jumlah memori dalam byte di mana peristiwa 'freemem' dipicu. Juga bisa menjadi persentase dari memori total. Default: 0

uptime

Jumlah detik dari acara mana 'uptime' dipicu. Default: Tidak ditentukan

Diskfree

Objek yang berisi nilai blok gratis, untuk jalur sistem file yang diberikan, di bawah peristiwa 'DiskFree' yang dipicu. Didukung dari Node.js v18.15.x dan yang lebih baru. (ref.) default: {}

Critical1

Nilai rata -rata beban 1 menit di mana peristiwa 'loadavg1' dipicu. Default: os.cpus (). Panjang

(Konsep khusus UNIX, rata-rata beban adalah ukuran aktivitas sistem, dihitung oleh sistem operasi dan dinyatakan sebagai angka fraksional. Sebagai aturan praktis, rata-rata beban idealnya kurang dari jumlah CPU logis dalam sistem.

Critical5

Nilai rata -rata beban 5 menit di mana peristiwa 'loadavg5' dipicu. Default: os.cpus (). Panjang

Critical15

Nilai rata -rata beban 15 menit di atas acara mana 'loadavg15' dipicu. Default: os.cpus (). Panjang

diam

Setel ke Mute Event 'Monitor'. Default: Salah

sungai kecil

Setel untuk mengaktifkan monitor sebagai aliran yang dapat dibaca. Default: Salah

segera

Tetapkan benar untuk menjalankan siklus monitor di start (). Default: Salah

API

.versi

Properti monitor.version berisi string versi os-monitor .

.start ([opsi])

Memulai monitor. Menerima objek opsi opsional.

.berhenti( )

Menghentikan monitor.

.isrunning ()

Memeriksa apakah monitor berjalan atau tidak; mengembalikan boolean.

.config ([opsi])

Menerima objek opsi opsional dan memperbarui konfigurasi monitor. Selalu mengembalikan opsi konfigurasi monitor.

.mengatur ulang( )

Reset monitor konfigurasi ke nilai defaultnya.

.on (EventType, Handler), .addlistener (EventType, Handler)

Menambahkan pendengar untuk jenis acara yang ditentukan. Acara yang didukung adalah: 'monitor', 'uptime', 'freemem', 'diskfree', 'loadavg1', 'loadavg5', 'loadavg15', 'start', 'stop', 'config', 'reset', 'hancurkan'.

.once (EventType, Handler)

Menambahkan pendengar satu kali untuk jenis acara yang ditentukan. Pendengar ini dipanggil hanya pada saat acara berikutnya ditembakkan, setelah itu dihapus.

.throttle (EventType, Handler, Delay)

Menambahkan pendengar yang dilemparkan. Pendengar throttled tidak akan dieksekusi lebih dari sekali setiap penundaan milidetik.

.Unthrottle (EventType, Handler)

Menghapus pendengar yang dilemparkan sebelumnya ditambahkan menggunakan .throttle() . handler harus menjadi fungsi asli.

. WHEN (EventType)

Mengembalikan janji yang diselesaikan dengan objek acara ketika eventType dipicu.

.menghancurkan( )

Berhenti secara permanen dan menonaktifkan monitor.

.seconds (n), .minutes (n), .Hours (n), .days (n)

Metode kenyamanan untuk mendapatkan jumlah milidetik yang tepat.

 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 ) } ) ;

.blocks (byte, blocksize)

Metode kenyamanan untuk mendapatkan jumlah blok sistem file yang tepat.

 monitor . blocks ( 100000000 , 4096 ) ; // -> 24415 blocks

// start by observing file system path `/filesystem`
monitor . start ( {
  diskfree : {
    '/filesystem' : monitor . blocks ( 100000000 , 4096 )
  }
} ) ; 

Objek acara

Ada beberapa informasi berguna dalam objek acara yang disediakan:

 {
  "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
}

Semua acara yang didukung adalah: 'monitor', 'uptime', 'freemem', 'diskfree', 'loadavg1', 'loadavg5', 'loadavg15', 'start', 'stop', 'config', 'reset', 'hancurkan'. Perhatikan bahwa os-monitor adalah contoh dari EventEmitter .

Acara API Docs: nodejs.org/api/events

Menggunakan monitor sebagai aliran yang dapat dibaca

os-monitor juga dapat digunakan sebagai aliran yang dapat dibaca.

 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);

Janji

os-monitor mendukung Promise, Async/Await: Menggunakan .when(eventType) mengembalikan janji.

 monitor.when('freemem').then(event => {
    // ...
});

async function callback() {
    let event = await monitor.when('uptime');
    // ...
}

Kelas Monitor

Butuh contoh monitor bersamaan? Beberapa contoh dapat dibuat menggunakan kelas Monitor :

 const { Monitor } = require('os-monitor');

let monitor1 = new Monitor();
let monitor2 = new Monitor();
let monitor3 = new Monitor();

Lisensi

os-monitor dirilis di bawah lisensi MIT.

100% GRATIS: os-monitor dapat digunakan secara bebas dalam proyek kepemilikan dan sumber terbuka.

Atribusi diperlukan: Anda harus menyimpan nama penulis dan informasi lisensi dalam kode terdistribusi apa pun. Item-item ini tidak perlu menghadap pengguna dan dapat tetap berada di dalam basis kode.