Ici pour vous dire sous la supervision de la performance NodeJS,

  Récemment, je veux surveiller les performances d''environ NodeJS.Analyse des journaux d''enregistrement trop de problèmes, la meilleure fa?on est d''enregistrer le temps de traitement pour chaque requête HTTP, l''en-tête de réponse HTTP directement retourné dans.

  requêtes HTTP temps d''enregistrement est très simple, un horodatage est appelé à la réception de la demande, l''horodatage de demande de réponse d''une autre note, les deux timbres de temps est la différence entre le temps de traitement.

  Cependant, res.envoyer () code à travers les différents fichiers js, vous ne pouvez pas mettre toutes les URL gestionnaire ont changé à nouveau.

  idée correcte est mis en ?uvre dans le middleware.Mais pas NodeJS res d''interception.Méthode d''envoi (), comment briser?

  En fait, juste un peu de changement ma fa?on de penser, d''abandonner le chemin de la POO traditionnelle de regarder la res fonction d''objet.envoyer (), nous serons en mesure d''enregistrer les res de gestionnaire d''origine.envoyer, puis ses gestionnaires remplacent res.envoyer:

  app.utilisation (fonction (req, res, à c?té) {

  // enregistrement Heure de début:

  var = Date exec_start_at.maintenant ();

  // sauvegarde le gestionnaire d''origine:

  var = _Envoyer res.envoyer;

  // bind notre propre gestionnaire:

  res.send = function () {

  // Envoyer en-tête:

  res.set ( ''X-exécution-Time'', String (date.maintenant () - exec_start_at));

  // appeler le gestionnaire d''origine:

  retour _Envoyer.appliquer (res, des arguments);

  };

  prochain ();

  }); ''

  Seules quelques lignes de code, mettre un timbre de temps pour obtenir.

  pour res.render () ne nécessite pas de traitement, parce que res.render () appelle en interne la res.envoyer ().

  cet appel applique la fonction (), les objets res entrants est très important, sinon le pointage du gestionnaire d''origine non défini résultat direct de l''erreur.

  Accueil 9 ms Temps de réponse Trouvés:

  

  ps: pour introduire la méthode suivante dans nodejs moniteur de bureau à distance, le contenu de spécifiques sont les suivants:

  noeuds récents outils d''une application de surveillance à distance, le bureau de bureau dans le serveur et le client, le client peut surveiller serveur en temps réel, et le serveur peut être contr?lé par la souris et le clavier de bureau.

  

  Parce qu''ici je suis en utilisant le même ordinateur, l''écran est, bien s?r, utilisez deux ordinateurs exécutant un client, une course de serveur est logique.

  principe

  En fait, la fonction principale de cette application est divisée en deux parties, l''une est d''obtenir un contr?le, que vous pouvez voir le serveur de bureau sur le c?té client, cette partie de la fonction est obtenue par des coups réguliers, tels que les extrémités de service une deuxième carte, coupé plusieurs fois, puis priseio envoyé au client, le client pour obtenir un cadre d''affichage de la dernière image en changeant la img src, afin que vous puissiez voir le bureau dynamique.Un tel suivi est mis en ?uvre.

  Une autre fonction est de contr?ler que le client sur l''écran de l''opération, y compris le fonctionnement de la souris et le clavier sont disponibles dans l''entrée réelle de bureau en vigueur du serveur, pour réaliser cette partie de la fonction est de surveiller tous les événements de la souris et du clavier dans l''application de son électronique tels que keydown, keyup, keypress, Sourisdown, Sourisup, Sourismove, cliquez sur, etc., puis passer par priseio événements au serveur, le serveur pour effectuer différents événements à travers le robot-js, de sorte que vous pouvez faire l''événement du client à la gachette du serveur les.

  atteindre

  Principe fini, nous devons examiner la mise en ?uvre spécifique (code source à ce lien).

  communication par prise Réalisation

  Tout d''abord, le serveur et le client sont introduits prise.io et la douille.io-client, sont initialisés

  Serveur:

  app = const nouveau Koa ();

  serveur const = http.createServer (app.le rappel ());

  createSocketIO (serveur);

  app.vide => {: l''utilisation ((CTX)

  CTX.body = ? Veuillez prise utilisation de connexion ?;

  });

  serveur.LISTEN (port, (): void => {

  console.log ( ''serveur a démarré à l''adresse http: // localhost:'' + port);

  });

  // createSocketIO

  const io = priseIO (serveur, {

  PingInterval: 10000,

  pingTimeout: 5000,

  cookie: faux

  });

  io.sur ( ''connecter'', (prise): void => {

  prise.emit ( ''msg'', ''connecté'');

  }

  Client:

  Prise var = Cette.socket = io ( ''http: //'' + cette.ip + '': 3000'')

  socket.sur ( ''msg'', (msg) => {

  console.log (msg)

  })

  socket.sur ( ''erreur'', (err) => {

  alert ( ''mauvais'' + err)

  })

  De cette fa?on, le serveur et le client afin d''établir un lien par socketio.

  Mettre en ?uvre la surveillance de bureau

  Ensuite, nous devons d''abord être tourné sur le serveur, en utilisant le paquet capture d''écran-desktop

  const capture d''écran = require ( ''capture d''écran-desktop'')

  const SCREENSHOT_INTERVAL = 500;

  export const createScreenshot = (): Promise<[string, Buffer]>=> {

  capture d''écran de retour ({format suivant: ''.png''}).puis ((img): [string, tampon] => {

  retour [img.toString ( ''base64''), img];

  }).catch ((err): {} => {

  console.log ( ''échec de capture d''écran'', err);

  retourner err;

  })

  }

  export const startScreenshotTimer = (rappel): {} => {

  vide => {: retour setInterval (()

  createScreenshot ().puis (([imgStr, img]): void => {

  rappel ([ ''data: image / png; base64,'' + imgStr, img]);

  })

  }, SCREENSHOT_INTERVAL)

  }

  Le client est ensuite passé à travers emit socketio de:

  startScreenshotTimer (([imgStr, img]): void => {

  io.prises de courant.emit ( ''capture'', imgStr);

  });

  Le client après avoir re?u l''image, réglez le img src (photo ici est url base64):

  

  class = "capture d''écran"

  : = Src ? https: // www.jb51.net / article / capture d''écran "

  />

  Les données () {

  revenir {

  capture d''écran: ''''

  }

  }

  socket.sur ( ''écran'', (données) => {

  cette.Capture = données

  })

  En fait, cela a été réalisé sur un moniteur de bureau, les étudiants intéressés peuvent obtenir un aspect brillant cette idée, pas beaucoup de mal à.

  Bien s?r, une telle approche est problématique, car nous avons besoin de conna?tre la taille de la taille du bureau du serveur, puis en fonction de ce client pour régler la taille de l''image affichée.

  Atteindre cet objectif détail est d''obtenir pixels utilisent cette bibliothèque, vous pouvez lire des informations telles que la hauteur largeur fichier image locale, donc je mets l''image est écrit localement, puis lire, donc arriver à la taille de l''écran.

  Interface ScreenSize {

  largeur: nombre;

  hauteur: nombre;

  }

  fonction getScreenSize (img): Promise {

  const imgPath = path.détermination (processus.CWD (), ? https: // www.jb51.net / article / tmp.png ? );

  fs.writeFileSync (imgPath, img);

  retour nouvelle promesse ((résolution): void => {

  getPixels (imgPath, la fonction (err, pixels): void {

  si (err) {

  console.log ( "Bad Chemin d''image")

  revenir

  }

  résoudre ({

  largeur: pixels.forme [0],

  hauteur: pixels.forme [1]

  });

  });

  })

  }

  Il est ensuite transmis au client par socektio

  getScreenSize (img).puis (({largeur, hauteur}) => {

  io.prises de courant.émettre ( ''screensize'', {

  largeur,

  la taille

  })

  });

  Dès réception du client pour régler la taille de l''image sur elle

  

  class = "capture d''écran"

  : = Src ? https: // www.jb51.net / article / capture d''écran "

  : Style = "screenshotStyle"

  />

  Les données () {

  revenir {

  capture d''écran: '''',

  screenshotStyle: '''',

  }

  }

  socket.sur ( ''screensize'', (screensize) => {

  cette.screenshotStyle = { ''width'': screensize.largeur + ''px'', ''height'': screensize.hauteur + ''px''}

  })

  Jusqu''à présent, il a réalisé un moniteur de bureau, et la taille de l''image et la taille de l''écran serveur est le même.

  Ici, il y a un détail, est d''arriver à la taille du pixel physique de l''image est plut?t px les paramètres du client sont des pixels indépendants du périphérique, qui est divisée par la valeur de px est DPR.Vous devriez obtenir DPR, car actuellement utilisé seulement dans le Mac, de sorte que le directe divisé par 2.

  Télécommande

  Code écrit ici, l''application client électronique peut afficher des services de bureau en temps réel ont été la fin de.(Bien s?r, les détails du bloc élastique d''image d''entrée, et des électrons vue dactylographiée et similaires, et la logique principale non pertinents non effectuées.)

  Ensuite, nous voulons obtenir un contr?le à distance, qui est, écouter les événements, passer l''événement, l''événement ces pièces.

  Tout d''abord, nous définissons les événements de transfert de format:

  Interface SourisEvent {

  Type: cha?ne;

  ButtonType: string;

  x: nombre;

  y: nombre;

  }

  Interface KeyboardEvent {

  Type: cha?ne;

  codeTouche: nombre;

  keyName: string;

  }

  Souris événement MouseEvent, le type d''un type d''événement de souris, les valeurs spécifiques comprennent Sourisdown, Sourisup, mousemove, clic, dblclick, ButtonType se réfère à la souris vers la gauche ou la droite, ou gauche est droite, x et y sont les coordonnées du particulier.

  Les événements clavier KeyboardEvent, le type est le type d''événements de clavier, les valeurs spécifiques sont KEYDOWN, keyup, keypress, codeTouche code clavier, keyName pour le nom de clé.

  Ensuite, nous voulons écouter les événements sur le client:

  

  class = "capture d''écran"

  : = Src ? https: // www.jb51.net / article / capture d''écran "

  : Style = "screenshotStyle"

  @ MouseDown = "handleMouseEvent"

  @ MouseMove = "handleMouseEvent"

  @ Mouseup = "handleMouseEvent"

  @ Cliquez = "handleMouseEvent"

  @ DBLCLICK = "handleMouseEvent"

  />

  fenêtre.onkeypress = fenêtre.onkeyup = fenêtre.onkeydown = ce.handleKeyboardEvent

  Les événements sont transmis au serveur par socekt

  handleKeyboardEvent (e) {

  cette.&& cette douille.socket.émettre ( ''userevent'', {

  tapez: ? clavier ?,

  un événement: {

  Type: e.type,

  keyName: e.clé,

  codeTouche: e.code clé

  }

  })

  },

  handleMouseEvent (e) {

  cette.&& cette douille.socket.émettre ( ''userevent'', {

  tapez: ? souris ?,

  un événement: {

  Type: e.type,

  ButtonType: e.boutons === 2 ? ''Droite gauche'',

  x: e.clientX,

  vous.clientY

  }

  })

  },

  Puis à la fin de l''événement pris sur l''exécution des services, des événements d''exécution à l''aide robot-js:

  const {Mouse, point, clavier} = require ( ''robot-js'');

  Interface MouseEvent {

  Type: cha?ne;

  ButtonType: string;

  x: nombre;

  y: nombre;

  }

  Interface KeyboardEvent {

  Type: cha?ne;

  codeTouche: nombre;

  keyName: string;

  }

  export classe par défaut EventExecuter {

  souris publique;

  Clavier public;

  constructeur public () {

  cette.Souris = nouvelle souris ();

  cette.Clavier = nouveau clavier ();

  }

  executeKeyboardEvent publique (événement: KeyboardEvent): void {

  commutateur (événement.type) {

  case ''keydown'':

  cette.clavier.presse (événement.code clé);

  Pause;

  case ''keyup'':

  cette.clavier.sortie (événement.code clé);

  Pause;

  case ''keypress'':

  cette.clavier.cliquez sur (événement.code clé);

  Pause;

  par défaut: rupture;

  }

  }

  executeMouseEvent publique (event): void {

  Mouse.setPos (nouveau point (événement.x, événement.Y));

  Bouton const = événement.ButtonType === ''left'' ? 0: 2

  commutateur (événement.type) {

  case ''mousedown'':

  cette.mouse.appuie sur le bouton);

  Pause;

  case ''mousemove'':

  Pause;

  case ''mouseup'':

  cette.mouse.libérer (bouton);

  Pause;

  cas ? clic ?:

  cette.mouse.cliquez sur (bouton);

  Pause;

  case ''dblclick'':

  cette.mouse.cliquez sur (bouton);

  cette.mouse.cliquez sur (bouton);

  Pause;

  par défaut: rupture;

  }

  }

  exectue publique (EventInfo): void {

  console.log (EventInfo);

  commutateur (EventInfo.type) {

  case ''clavier'':

  cette.executeKeyboardEvent (EventInfo.un événement);

  Pause;

  cas ? souris ?:

  cette.executeMouseEvent (EventInfo.un événement);

  Pause;

  par défaut: rupture;

  }

  }

  }

  à ce stade, une partie du client ainsi que le contr?le à distance c?té serveur et de surveillance de bureau et de la communication aux deux extrémités ont été atteints.En fait, l''idée est pas problème, mais encore beaucoup de détails.Les étudiants intéressés peuvent essayer de mettre bas en cours d''exécution que sous le code ou en appuyant sur cette idée de réaliser leur propre nouveau, ou vraiment amusant.

  Pour résumer

  La méthode ci-dessus est NodeJS petite série à introduire un contr?le de bureau à distance, et nous voulons aider, si vous avez des questions, veuillez me donner rapidement un message, Xiao Bian répondra à votre!

  Vous pouvez également être intéressé par l''article: Java comparaison des performances de plusieurs bibliothèque JSON commune explique comment mettre à niveau vue.connexions js et les propriétés des trois grandes comparaison de cha?nes Javascript données de performance Explication sur JSON.parse () et JSON.La méthode des stringify () tests de performance JS couramment utilisés dans plusieurs analyses petit tableau de performances traversal et la performance détaillée de l''exemple comparatif de la mise en ?uvre des principes de l''ordre de charge pour améliorer les articles de performance en utilisant la carte de JavaScript détaillée

exemples de code suivi de la performance NodeJS

Recommend Article: