经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » JS/JS库/框架 » Node.js » 查看文章
监控Nodejs的性能实例代码
来源：jb51　　时间：2019/7/3 8:38:58　　对本文有异议

下面给大家介绍下监控Nodejs的性能，

最近想监控一下Nodejs的性能。记录分析Log太麻烦，最简单的方式是记录每个HTTP请求的处理时间，直接在HTTP Response Header中返回。

记录HTTP请求的时间很简单，就是收到请求记一个时间戳，响应请求的时候再记一个时间戳，两个时间戳之差就是处理时间。

但是，res.send()代码遍布各个js文件，总不能把每个URL处理函数都改一遍吧。

正确的思路是用middleware实现。但是Nodejs没有任何拦截res.send()的方法，怎么破？

其实只要稍微转换一下思路，放弃传统的OOP方式，以函数对象看待res.send()，我们就可以先保存原始的处理函数res.send，再用自己的处理函数替换res.send：

  1. app.use(function (req, res, next) {
  2.   // 记录start time:
  3.   var exec_start_at = Date.now();
  4.   // 保存原始处理函数:
  5.   var _send = res.send;
  6.   // 绑定我们自己的处理函数:
  7.   res.send = function () {
  8.     // 发送Header:
  9.     res.set('X-Execution-Time', String(Date.now() - exec_start_at));
  10.     // 调用原始处理函数:
  11.     return _send.apply(res, arguments);
  12.   };
  13.   next();
  14. });‘

只用了几行代码，就把时间戳搞定了。

对于res.render()方法不需要处理，因为res.render()内部调用了res.send()。

调用apply()函数时，传入res对象很重要，否则原始的处理函数的this指向undefined直接导致出错。

实测首页响应时间9毫秒：

x-execution-time

ps：下面给大家介绍下nodejs实现远程桌面监控的方法，具体内容如下所示：

最近使用node实现了一个远程桌面监控的应用，分为服务端和客户端，客户端可以实时监控服务端的桌面，并且可以通过鼠标和键盘来控制服务端的桌面。

这里因为我是用的同一台电脑，所以监控画面是这样的，当然使用两台电脑一个跑 客户端 ，一个跑 服务端 才有意义。

原理

其实这个应用的功能主要分为两部分，一是实现监控，即在客户端可以看到服务端的桌面，这部分功能是通过定时截图来实现的，比如服务端一秒截几次图，然后通过 socketio 发送到客户端，客户端通过改变img的src来实现一帧帧的显示最新的图片，这样就能看到动态的桌面了。监控就是这样实现的。

另一个功能是控制，即客户端对监控画面的操作，包括鼠标和键盘的操作都可以在服务端的桌面真正的生效，这部分功能的实现是在electron的应用中监听了所有的鼠标和键盘事件，比如keydown、keyup、keypress，mousedown、mouseup、mousemove、click等，然后通过socketio把事件传递到服务端，服务端通过 robot-js 来执行不同的事件，这样就能使得客户端的事件在服务端触发了。

实现

原理讲完，我们来具体实现一下（ 源码链接在这 ）。

实现socket通信

首先，服务端和客户端分别引入 socket.io 和 socket.io-client , 分别初始化

服务端：

  1. const app = new Koa();
  2. const server = http.createServer(app.callback());
  3. createSocketIO(server);
  4.  
  5. app.use((ctx): void => {
  6.  ctx.body = 'please connect use socket';
  7. });
  8.  
  9. server.listen(port, (): void => {
  10.  console.log('server started at http://localhost:' + port);
  11. });
  1. //createSocketIO
  2. const io = socketIO(server, {
  3.  pingInterval: 10000,
  4.  pingTimeout: 5000,
  5.  cookie: false
  6.  });
  7. io.on('connect', (socket): void => {
  8.  socket.emit('msg', 'connected');
  9. }

客户端：

  1. var socket = this.socket = io('http://' + this.ip + ':3000')
  2. socket.on('msg', (msg) => {
  3.  console.log(msg)
  4. })
  5. socket.on('error', (err) => {
  6.  alert('出错了' + err)
  7. })

这样，服务端和客户端就通过socketio建立了链接。

实现桌面监控

之后我们首先要在服务端来截图，使用 screenshot-desktop 这个包

  1. const screenshot = require('screenshot-desktop')
  2.  
  3. const SCREENSHOT_INTERVAL = 500;
  4.  
  5. export const createScreenshot = (): Promise<[string, Buffer]> => {
  6.  return screenshot({format: 'png'}).then((img): [string, Buffer] => {
  7.  return [ img.toString('base64'), img];
  8.  }).catch((err): {} => {
  9.  console.log('截图失败', err);
  10.  return err;
  11.  })
  12. }
  13.  
  14. export const startScreenshotTimer = (callback): {} => {
  15.  return setInterval((): void => {
  16.  createScreenshot().then(([imgStr, img]): void => {
  17.   callback(['data:image/png;base64,' + imgStr, img]);
  18.  })
  19.  }, SCREENSHOT_INTERVAL)
  20. }

然后通过socketio的emit来传到客户端：

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

客户端收到图片后，设置到img的src上（这里是base64的图片url）:

  1. <img 
  2.  class="screenshot" 
  3.  :src="screenshot"
  4. />
  5.  
  6. data () {
  7.  return {
  8.  screenshot: ''
  9.  }
  10. }
  11.  
  12. socket.on('screenshot', (data) => {
  13.  this.screenshot = data
  14. })

其实这样就已经实现了桌面监控了，有兴趣的同学可以照着这个思路实现看看，并不是很麻烦。

当然这样的方案是有问题的，因为我们需要知道服务端桌面尺寸的大小，然后根据这个来调整客户端显示的图片尺寸。

实现这个细节是使用的 get-pixels 这个库，可以读取本地图片文件的宽度高度等信息，所以我先把图片写入本地，然后又读取出来，这样获取到的屏幕尺寸。

  1. interface ScreenSize {
  2.  width: number;
  3.  height: number;
  4. }
  5.  
  6. function getScreenSize(img): Promise<ScreenSize> {
  7.  const imgPath = path.resolve(process.cwd(), './tmp.png');
  8.  fs.writeFileSync(imgPath, img);
  9.  return new Promise((resolve): void => {
  10.  getPixels(imgPath, function(err, pixels): void {
  11.   if(err) {
  12.   console.log("Bad image path")
  13.   return
  14.   }
  15.   resolve({
  16.   width: pixels.shape[0],
  17.   height: pixels.shape[1]
  18.   });
  19.  });
  20.  })
  21. }

然后通过socektio传递给客户端

  1. getScreenSize(img).then(({ width, height}) => {
  2.  io.sockets.emit('screensize', {
  3.  width,
  4.  height
  5.  })
  6. });

客户端收到之后调整图片大小就可以了

  1. <img 
  2.  class="screenshot" 
  3.  :src="screenshot"
  4.  :style="screenshotStyle"
  5. />
  6.  
  7. data () {
  8.  return {
  9.  screenshot: '',
  10.  screenshotStyle: '',
  11.  }
  12. }
  13.  
  14. socket.on('screensize', (screensize) => {
  15.  this.screenshotStyle = {'width': screensize.width + 'px', 'height': screensize.height + 'px'}
  16. })

至此已经实现了桌面监控，并且图片尺寸和服务端屏幕的尺寸是一致的。

这里还有一个细节，就是获取到的图片大小是物理像素，而客户端设置的px是设备无关像素，也就是要除以dpr才是px的值。这里需要获取dpr，因为目前只是在mac下用，所以直接除以2了。

实现远程控制

代码写到这里，客户端的electron应用中已经可以实时显示服务端的桌面了。（当然像输入ip的弹框，以及electron-vue和typescript等和主要逻辑无关的细节就不展开了。）

接下来我们要实现远程控制，也就是监听事件，传递事件，执行事件这几部分。

首先我们定义一下传递的事件的格式：

  1. interface MouseEvent {
  2.  type: string;
  3.  buttonType: string;
  4.  x: number;
  5.  y: number;
  6. }
  7.  
  8. interface KeyboardEvent {
  9.  type: string;
  10.  keyCode: number;
  11.  keyName: string;
  12. }

鼠标事件MouseEvent，type为鼠标事件的类型，具体的值包括mousedown、mouseup、mousemove、click、dblclick，buttonType指的是鼠标的左键还是右键，值为 left 或 right，x和y是具体的坐标。

键盘事件KeyboardEvent，type为键盘事件的类型，具体的值包括keydown、keyup、keypress，keyCode为键盘码，keyName为键的名字。

接下来我们要在客户端监听事件：

  1. <img 
  2.  class="screenshot" 
  3.  :src="screenshot"
  4.  :style="screenshotStyle"
  5.  @mousedown="handleMouseEvent"
  6.  @mousemove="handleMouseEvent" 
  7.  @mouseup="handleMouseEvent"
  8.  @click="handleMouseEvent"
  9.  @dblclick="handleMouseEvent" 
  10. />
  11.  
  12. window.onkeypress = window.onkeyup = window.onkeydown = this.handleKeyboardEvent

通过socekt把事件传递到服务端

  1. handleKeyboardEvent (e) {
  2.  this.socket && this.socket.emit('userevent', {
  3.  type: 'keyboard',
  4.  event: {
  5.  type: e.type,
  6.  keyName: e.key,
  7.  keyCode: e.keyCode
  8.  }
  9.  })
  10.  },
  11.  handleMouseEvent (e) {
  12.  this.socket && this.socket.emit('userevent', {
  13.  type: 'mouse',
  14.  event: {
  15.  type: e.type,
  16.  buttonType: e.buttons === 2 ? 'right' : 'left',
  17.  x: e.clientX,
  18.  y: e.clientY
  19.  }
  20.  })
  21.  },

然后在服务端把事件取出来执行，执行事件使用的是 robot-js ：

  1. const { Mouse, Point, Keyboard } = require('robot-js');
  2.  
  3. interface MouseEvent {
  4.  type: string;
  5.  buttonType: string;
  6.  x: number;
  7.  y: number;
  8. }
  9.  
  10. interface KeyboardEvent {
  11.  type: string;
  12.  keyCode: number;
  13.  keyName: string;
  14. }
  15.  
  16. export default class EventExecuter {
  17.  public mouse;
  18.  public keyboard;
  19.  public constructor(){
  20.  this.mouse = new Mouse();
  21.  this.keyboard = new Keyboard();
  22.  }
  23.  
  24.  public executeKeyboardEvent(event: KeyboardEvent): void {
  25.  switch(event.type) {
  26.   case 'keydown':
  27.   this.keyboard.press(event.keyCode);
  28.   break;
  29.   case 'keyup':
  30.   this.keyboard.release(event.keyCode);
  31.   break;
  32.   case 'keypress':
  33.   this.keyboard.click(event.keyCode);
  34.   break;
  35.   default: break;
  36.  }
  37.  }
  38.  
  39.  public executeMouseEvent(event): void {
  40.  Mouse.setPos(new Point(event.x, event.y));
  41.  const button = event.buttonType === 'left' ? 0 : 2
  42.  switch(event.type) {
  43.   case 'mousedown':
  44.   this.mouse.press(button);
  45.   break;
  46.   case 'mousemove':
  47.   break;
  48.   case 'mouseup': 
  49.   this.mouse.release(button);
  50.   break;
  51.   case 'click': 
  52.   this.mouse.click(button);
  53.   break;
  54.   case 'dblclick': 
  55.   this.mouse.click(button);
  56.   this.mouse.click(button);
  57.   break;
  58.   default: break;
  59.  }
  60.  }
  61.  
  62.  public exectue(eventInfo): void {
  63.  console.log(eventInfo);
  64.  switch (eventInfo.type) {
  65.   case 'keyboard':
  66.   this.executeKeyboardEvent(eventInfo.event);
  67.   break;
  68.   case 'mouse':
  69.   this.executeMouseEvent(eventInfo.event);
  70.   break;
  71.   default: break;
  72.  }
  73.  }
  74. }

至此，桌面监控和远程控制的客户端还有服务端的部分，以及两端的通信都已经实现了。思路其实并不麻烦，但细节还是很多的。有兴趣的同学可以把代码下下来跑跑试试，或者按着这个思路自己实现一遍，还是挺好玩的。

总结

以上所述是小编给大家介绍的nodejs实现远程桌面监控的方法，希望对大家有所帮助，如果大家有任何疑问欢迎给我留言，小编会及时回复大家的！

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Node.js热门文章

  • node.js学习笔记之koa框架和简单爬虫练习
  • node版本管理工具n包使用教程详解
  • 一文教会你从Windows中完全删除node.js
  • AntvG6-graph图谱工具
  • node.js express框架实现文件上传与下载功能实例详解
  • Node.js 串口通讯 node-serialport
  • NodeJS实现图片文本分割
  • nodejs fastdfs
  • nodejs实现UDP组播示例方法
  • express框架中使用jwt实现验证的方法

    • Node.js推荐文章

  • AntvG6-graph图谱工具
  • 一篇文章搞定什么是nodeJs它和NPM关系与应用
  • Node + Express 后台开发 —— 上传、下载和发布
  • Node.js躬行记（28）——Cypress自动化测试实践
  • NodeJS 实战系列：个人开发者应该如何选购云服务
  • NodeJS V8引擎的内存和垃圾回收器（GC）
  • 【ASP.NET Core】在node.js上托管Blazor WebAssembly应用
  • Node.js 未来发展趋势
  • 从零开始，打造属于你的 ChatGPT 机器人！
  • Node.js躬行记（25）——Web自动化测试

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号