監(jiān)控Nodejs的性能實例代碼

更新時間：2019年07月02日 16:19:26 作者：凌霄光

這篇文章主要介紹了監(jiān)控Nodejs的性能實例代碼,本文給大家介紹的非常詳細，具有一定的參考借鑒價值，需要的朋友可以參考下

下面給大家介紹下監(jiān)控Nodejs的性能，

最近想監(jiān)控一下Nodejs的性能。記錄分析Log太麻煩，最簡單的方式是記錄每個HTTP請求的處理時間，直接在HTTP Response Header中返回。

記錄HTTP請求的時間很簡單，就是收到請求記一個時間戳，響應(yīng)請求的時候再記一個時間戳，兩個時間戳之差就是處理時間。

但是，res.send()代碼遍布各個js文件，總不能把每個URL處理函數(shù)都改一遍吧。

正確的思路是用middleware實現(xiàn)。但是Nodejs沒有任何攔截res.send()的方法，怎么破？

其實只要稍微轉(zhuǎn)換一下思路，放棄傳統(tǒng)的OOP方式，以函數(shù)對象看待res.send()，我們就可以先保存原始的處理函數(shù)res.send，再用自己的處理函數(shù)替換res.send：

app.use(function (req, res, next) {
  // 記錄start time:
  var exec_start_at = Date.now();
  // 保存原始處理函數(shù):
  var _send = res.send;
  // 綁定我們自己的處理函數(shù):
  res.send = function () {
    // 發(fā)送Header:
    res.set('X-Execution-Time', String(Date.now() - exec_start_at));
    // 調(diào)用原始處理函數(shù):
    return _send.apply(res, arguments);
  };
  next();
});‘

只用了幾行代碼，就把時間戳搞定了。

對于res.render()方法不需要處理，因為res.render()內(nèi)部調(diào)用了res.send()。

調(diào)用apply()函數(shù)時，傳入res對象很重要，否則原始的處理函數(shù)的this指向undefined直接導(dǎo)致出錯。

實測首頁響應(yīng)時間9毫秒：

x-execution-time

ps：下面給大家介紹下nodejs實現(xiàn)遠程桌面監(jiān)控的方法，具體內(nèi)容如下所示：

最近使用node實現(xiàn)了一個遠程桌面監(jiān)控的應(yīng)用，分為服務(wù)端和客戶端，客戶端可以實時監(jiān)控服務(wù)端的桌面，并且可以通過鼠標(biāo)和鍵盤來控制服務(wù)端的桌面。

這里因為我是用的同一臺電腦，所以監(jiān)控畫面是這樣的，當(dāng)然使用兩臺電腦一個跑客戶端，一個跑服務(wù)端才有意義。

原理

其實這個應(yīng)用的功能主要分為兩部分，一是實現(xiàn)監(jiān)控，即在客戶端可以看到服務(wù)端的桌面，這部分功能是通過定時截圖來實現(xiàn)的，比如服務(wù)端一秒截幾次圖，然后通過 socketio 發(fā)送到客戶端，客戶端通過改變img的src來實現(xiàn)一幀幀的顯示最新的圖片，這樣就能看到動態(tài)的桌面了。監(jiān)控就是這樣實現(xiàn)的。

另一個功能是控制，即客戶端對監(jiān)控畫面的操作，包括鼠標(biāo)和鍵盤的操作都可以在服務(wù)端的桌面真正的生效，這部分功能的實現(xiàn)是在electron的應(yīng)用中監(jiān)聽了所有的鼠標(biāo)和鍵盤事件，比如keydown、keyup、keypress，mousedown、mouseup、mousemove、click等，然后通過socketio把事件傳遞到服務(wù)端，服務(wù)端通過 robot-js 來執(zhí)行不同的事件，這樣就能使得客戶端的事件在服務(wù)端觸發(fā)了。

實現(xiàn)

原理講完，我們來具體實現(xiàn)一下（源碼鏈接在這）。

實現(xiàn)socket通信

首先，服務(wù)端和客戶端分別引入 socket.io 和 socket.io-client , 分別初始化

服務(wù)端：

const app = new Koa();
const server = http.createServer(app.callback());
createSocketIO(server);

app.use((ctx): void => {
 ctx.body = 'please connect use socket';
});

server.listen(port, (): void => {
 console.log('server started at http://localhost:' + port);
});

//createSocketIO
const io = socketIO(server, {
 pingInterval: 10000,
 pingTimeout: 5000,
 cookie: false
 });
io.on('connect', (socket): void => {
 socket.emit('msg', 'connected');
}

客戶端：

var socket = this.socket = io('http://' + this.ip + ':3000')
socket.on('msg', (msg) => {
 console.log(msg)
})
socket.on('error', (err) => {
 alert('出錯了' + err)
})

這樣，服務(wù)端和客戶端就通過socketio建立了鏈接。

實現(xiàn)桌面監(jiān)控

之后我們首先要在服務(wù)端來截圖，使用 screenshot-desktop 這個包

const screenshot = require('screenshot-desktop')

const SCREENSHOT_INTERVAL = 500;

export const createScreenshot = (): Promise<[string, Buffer]> => {
 return screenshot({format: 'png'}).then((img): [string, Buffer] => {
 return [ img.toString('base64'), img];
 }).catch((err): {} => {
 console.log('截圖失敗', err);
 return err;
 })
}

export const startScreenshotTimer = (callback): {} => {
 return setInterval((): void => {
 createScreenshot().then(([imgStr, img]): void => {
  callback(['data:image/png;base64,' + imgStr, img]);
 })
 }, SCREENSHOT_INTERVAL)
}

然后通過socketio的emit來傳到客戶端：

startScreenshotTimer(([imgStr, img]): void => {
 io.sockets.emit('screenshot', imgStr);
});

客戶端收到圖片后，設(shè)置到img的src上（這里是base64的圖片url）:

<img 
 class="screenshot" 
 :src="screenshot"
/>

data () {
 return {
 screenshot: ''
 }
}

socket.on('screenshot', (data) => {
 this.screenshot = data
})

其實這樣就已經(jīng)實現(xiàn)了桌面監(jiān)控了，有興趣的同學(xué)可以照著這個思路實現(xiàn)看看，并不是很麻煩。

當(dāng)然這樣的方案是有問題的，因為我們需要知道服務(wù)端桌面尺寸的大小，然后根據(jù)這個來調(diào)整客戶端顯示的圖片尺寸。

實現(xiàn)這個細節(jié)是使用的 get-pixels 這個庫，可以讀取本地圖片文件的寬度高度等信息，所以我先把圖片寫入本地，然后又讀取出來，這樣獲取到的屏幕尺寸。

interface ScreenSize {
 width: number;
 height: number;
}

function getScreenSize(img): Promise<ScreenSize> {
 const imgPath = path.resolve(process.cwd(), './tmp.png');
 fs.writeFileSync(imgPath, img);
 return new Promise((resolve): void => {
 getPixels(imgPath, function(err, pixels): void {
  if(err) {
  console.log("Bad image path")
  return
  }
  resolve({
  width: pixels.shape[0],
  height: pixels.shape[1]
  });
 });
 })
}

然后通過socektio傳遞給客戶端

getScreenSize(img).then(({ width, height}) => {
 io.sockets.emit('screensize', {
 width,
 height
 })
});

客戶端收到之后調(diào)整圖片大小就可以了

<img 
 class="screenshot" 
 :src="screenshot"
 :style="screenshotStyle"
/>

data () {
 return {
 screenshot: '',
 screenshotStyle: '',
 }
}

socket.on('screensize', (screensize) => {
 this.screenshotStyle = {'width': screensize.width + 'px', 'height': screensize.height + 'px'}
})

至此已經(jīng)實現(xiàn)了桌面監(jiān)控，并且圖片尺寸和服務(wù)端屏幕的尺寸是一致的。

這里還有一個細節(jié)，就是獲取到的圖片大小是物理像素，而客戶端設(shè)置的px是設(shè)備無關(guān)像素，也就是要除以dpr才是px的值。這里需要獲取dpr，因為目前只是在mac下用，所以直接除以2了。

實現(xiàn)遠程控制

代碼寫到這里，客戶端的electron應(yīng)用中已經(jīng)可以實時顯示服務(wù)端的桌面了。（當(dāng)然像輸入ip的彈框，以及electron-vue和typescript等和主要邏輯無關(guān)的細節(jié)就不展開了。）

接下來我們要實現(xiàn)遠程控制，也就是監(jiān)聽事件，傳遞事件，執(zhí)行事件這幾部分。

首先我們定義一下傳遞的事件的格式：

interface MouseEvent {
 type: string;
 buttonType: string;
 x: number;
 y: number;
}

interface KeyboardEvent {
 type: string;
 keyCode: number;
 keyName: string;
}

鼠標(biāo)事件MouseEvent，type為鼠標(biāo)事件的類型，具體的值包括mousedown、mouseup、mousemove、click、dblclick，buttonType指的是鼠標(biāo)的左鍵還是右鍵，值為 left 或 right，x和y是具體的坐標(biāo)。

鍵盤事件KeyboardEvent，type為鍵盤事件的類型，具體的值包括keydown、keyup、keypress，keyCode為鍵盤碼，keyName為鍵的名字。

接下來我們要在客戶端監(jiān)聽事件：

<img 
 class="screenshot" 
 :src="screenshot"
 :style="screenshotStyle"
 @mousedown="handleMouseEvent"
 @mousemove="handleMouseEvent" 
 @mouseup="handleMouseEvent"
 @click="handleMouseEvent"
 @dblclick="handleMouseEvent" 
/>

window.onkeypress = window.onkeyup = window.onkeydown = this.handleKeyboardEvent

通過socekt把事件傳遞到服務(wù)端

handleKeyboardEvent (e) {
 this.socket && this.socket.emit('userevent', {
 type: 'keyboard',
 event: {
 type: e.type,
 keyName: e.key,
 keyCode: e.keyCode
 }
 })
 },
 handleMouseEvent (e) {
 this.socket && this.socket.emit('userevent', {
 type: 'mouse',
 event: {
 type: e.type,
 buttonType: e.buttons === 2 ? 'right' : 'left',
 x: e.clientX,
 y: e.clientY
 }
 })
 },

然后在服務(wù)端把事件取出來執(zhí)行，執(zhí)行事件使用的是 robot-js ：

const { Mouse, Point, Keyboard } = require('robot-js');

interface MouseEvent {
 type: string;
 buttonType: string;
 x: number;
 y: number;
}

interface KeyboardEvent {
 type: string;
 keyCode: number;
 keyName: string;
}

export default class EventExecuter {
 public mouse;
 public keyboard;
 public constructor(){
 this.mouse = new Mouse();
 this.keyboard = new Keyboard();
 }

 public executeKeyboardEvent(event: KeyboardEvent): void {
 switch(event.type) {
  case 'keydown':
  this.keyboard.press(event.keyCode);
  break;
  case 'keyup':
  this.keyboard.release(event.keyCode);
  break;
  case 'keypress':
  this.keyboard.click(event.keyCode);
  break;
  default: break;
 }
 }

 public executeMouseEvent(event): void {
 Mouse.setPos(new Point(event.x, event.y));
 const button = event.buttonType === 'left' ? 0 : 2
 switch(event.type) {
  case 'mousedown':
  this.mouse.press(button);
  break;
  case 'mousemove':
  break;
  case 'mouseup': 
  this.mouse.release(button);
  break;
  case 'click': 
  this.mouse.click(button);
  break;
  case 'dblclick': 
  this.mouse.click(button);
  this.mouse.click(button);
  break;
  default: break;
 }
 }

 public exectue(eventInfo): void {
 console.log(eventInfo);
 switch (eventInfo.type) {
  case 'keyboard':
  this.executeKeyboardEvent(eventInfo.event);
  break;
  case 'mouse':
  this.executeMouseEvent(eventInfo.event);
  break;
  default: break;
 }
 }
}

至此，桌面監(jiān)控和遠程控制的客戶端還有服務(wù)端的部分，以及兩端的通信都已經(jīng)實現(xiàn)了。思路其實并不麻煩，但細節(jié)還是很多的。有興趣的同學(xué)可以把代碼下下來跑跑試試，或者按著這個思路自己實現(xiàn)一遍，還是挺好玩的。

總結(jié)

以上所述是小編給大家介紹的nodejs實現(xiàn)遠程桌面監(jiān)控的方法，希望對大家有所幫助，如果大家有任何疑問歡迎給我留言，小編會及時回復(fù)大家的！

您可能感興趣的文章: