DEV Community: Siqueira

Como identificar gargalos de memória em uma aplicação nodejs 🤩

Siqueira — Mon, 25 Jan 2021 04:03:17 +0000

Hoje normalmente não nos preocupamos com consumo recursos ao desenvolver uma nova aplicação, porém quando temos como pauta a performance da aplicação as coisas se complicam.

O problema:

Quando temos uma aplicação que não consegue lidar com consumo de memória, temos um problema.

Pois quando ela não auto gerencia os recursos disponíveis, ela corre grande risco de ficar indisponível, e até perder dados.

Um exemplo é uma aplicação que consome mensagens de alguma fila, se ela não controla a quantidade de mensagens a ser processada de acordo com os recursos disponíveis, ela pode acabar ultrapassado o limite de consumo e ser encerrada.

A Busca pela solução:

Quando isso ocorre temos alguns problemas que podem ser elencados, sua aplicação pode estar com Memory Leaks, ou estar consumindo mais RAM do que o disponível.

Tendo essas possibilidades em vista temos que investigar a execução da aplicação para coletar mais dados.

O primeiro passo é montar seu ambiente local para reproduzir o cenário, porém antes de seguir com a reprodução devemos configurar um pacote que nos ajudará a coletar métricas da nossa aplicação o heapdump.

A instalação e configuração é bem simples conforme abaixo:

Rode a aplicação utilizando o seguinte comando:



env NODE_HEAPDUMP_OPTIONS=nosignal node app.js

Após a configuração chegou a hora de encontrar o problema, ao rodar a aplicação temos como objetivo leva-la ao limite, após estourar o uso dos recursos e encerrar, a aplicação terá gerado um relatório de uso de recursos, você encontrará na pasta raiz.

Para que possamos identificar exatamente onde ocorre o problema também colete dados da aplicação no ponto de execução você acredita não ter gargalos.

E com isso podemos usar o chrome dev tools para visualizar o relatório conforme abaixo:

Após a importação temos acesso as métricas de consumo de memória da aplicação, devemos ficar atentos a alguns indicadores.

A linha do tempo, com ele você pode diagnosticar o uso excessivo de memória, para identificar os pontos do gargalo:

O gráfico que você vê exibirá a memória alocada para seu aplicativo. Se acontecer de estar consumindo uma quantidade cada vez maior disso ao longo do tempo (sem nunca cair), é uma indicação de que você pode ter um vazamento de memória(Memory Leak).

O perfil de um aplicativo saudável deve se parecer mais com uma curva dente de serra, pois a memória é alocada e depois liberada quando o coletor de lixo entra.

Depois de suspeitar que há um vazamento de memória, o profiler Heap pode ser usado para descobrir a origem do vazamento.

Encontrar problemas de memória mesmo com as métricas é complicado mas para começar é a visualização Resumo do perfilador de heap. Você pode então comparar os heaps snapshots coletados para confirmar quais alocações foram feitas junto com seu impacto na memória.

Em cada snapshot temos o consumo total de memória:

Após selecionar o snapshot desejado podemos ver todos tipos de variáveis e suas quantidades criadas durante a execução do app.

Devemos ficar atentos a dois indicadores Shallow Size, que representa o tamanho do objeto alocado em bytes.

E additional retained size que é o tamanho retido dos objetos, ou seja parte dos objetos que não é limpa com garbage collector.

Bom agora que estamos cientes do indicadores e temos dois relatórios em mãos temos como proximo passo comparar os dois.

Ao comparar temos como identificar partes do código que utilizar uma quantidade de memória maior. A investigação nem sempre é assertiva, porém ela nos da uma noção de onde atacar.

A solução:

Com todos os dados em mãos devemos implementar uma solução vamos usar como exemplo uma aplicação que consome mensagens de uma fila irrestritamente conforme a imagem abaixo:

Ao identificar que o gargalo é no consumo uma saída é gerenciar o consumo de mensagens de acordo com memória atual usada, e fazer isso utilizando a função "memoryUsage" nativa do nodejs, essa função retorna o objeto abaixo:



{
  rss: 4935680,
  heapTotal: 1826816,
  heapUsed: 650472,
  external: 49879,
  arrayBuffers: 9386
}

Para otimizar o uso de memória iremos consumir mensagens com base no indicador "heapUsed" que retorna a quantidade de memória alocada no momento. E também com base no total de memória disponível que pode ser obtido através da função "totalmem" presente dentro do modulo os, essa função retorna o total de memória em bytes disponível no ambiente.

No caso acima utilizamos a seguinte estratégia, antes de consumir uma mensagem verificamos o uso total de memória caso esteja dentro do limite seguro a aplicação segue com o processo, caso contrario ela espera o uso da memória diminuir para voltar a processar as mensagens.

Essa é uma das formas de controlar facilmente o uso de memória dentro de uma aplicação nodejs.

Espero que tenham gostado até a próxima!

How can i config tests in nodejs api with jest

Siqueira — Tue, 14 Jan 2020 22:42:07 +0000

Before we start the config we need to now some things:

Why test my app? 🤔

To make your service scalable, and more consistent!

What is jest? 💭

Because is the most complete and easy to use!

First of all you need to installing the packages below on your project:

Jest the test framework:

  yarn add jest -D

jest types is a inteliscense to use jest:

  yarn add @types/jest -D

Supertest is a framework to simulate http requisitions:

  yarn add supertest -D

Now we need to make initial jest config.

To do that we execute the command below:

  yarn jest --init

After that the console make some questions to you, you need to answer like the image below:

Now you will find a file called "jest.config.js" on your root project.

The next step is ajust this config file like below:

Bail is the option we set to define the number of errors that make the tests break, in this case i always like to set one:

 bail: 1,

Clearmocks is the option that clear mocks after tests, this option we set true:

clearMocks: true,

collectCoverage this option enable or disable the coe coverage, i like to set as true:

collectCoverage: true,

collectCoverageFrom this option define the path or file s to collect the coverage, usually i set the path where stay my business logic:

collectCoverageFrom: [
    'src/app/Controllers/*.js',
  ],

coverageDirectory is the place where jest can put the coverage result, i usualy put coverage inside the test folder:

 coverageDirectory: '__tests__/coverage',

coverageReporters this option set the type of reporters for coverage result, i like to user reports below:

 coverageReporters: ['text', 'lcov', 'json'],

testMatch this option set the test files extensions:

  testMatch: ['**/__tests__/**/*.test.js'],

Now we can create the folder structure as the image below:

And that is it, now you reandy to starting test your api with jest!

How to document a nodejs api with apidoc

Siqueira — Mon, 06 Jan 2020 18:21:55 +0000

What is "apidoc" ?

Apidoc is a package to create documentation for api from notes in your source code.

Where can i use it?

The service is compatible with any programming language that allow block documentation.

How can i use ?

First of all you need to configuring the environment:

install node from the link "https://nodejs.org/en/"
install apidoc by command line below:

  "npm install apidoc -g"

Now we can start configure the project:

install grunt-apidoc "npm install grunt-apidoc --save-dev"

Grunt is a task generator to apidoc

On your root of your project you need to create a "Grunfile.js"
- In your Gruntfile you need to add the options below to config the destination path to apidoc:

 apidoc: {
   myapp: {
     src: "app/",
     dest: "apidoc/"
   }
 }

After that you need to create a file called "apidoc.json" to include information about your project:

 {
   "name": "example",
   "version": "0.1.0",
   "description": "apiDoc basic example",
   "title": "Custom apiDoc browser title",
   "url" : "https://api.github.com/v1"
 }

Obs:. this file is optional, it is just to describe your project, and you can add this config in your package json if it's a node project, but I preffer a separated file.

Now we can start making documentation.

To start you just need to comment before your endpoint like below:

/**
 * @api {get} /user/:id Request User information
 * @apiName GetUser
 * @apiGroup User
 *
 * @apiParam {Number} id Users unique ID.
 *
 * @apiSuccess {String} firstname Firstname of the User.
 * @apiSuccess {String} lastname  Lastname of the User.
 *
 * @apiSuccessExample Success-Response:
 *     HTTP/1.1 200 OK
 *     {
 *       "firstname": "John",
 *       "lastname": "Doe"
 *     }
 *
 * @apiError UserNotFound The id of the User was not found.
 *
 * @apiErrorExample Error-Response:
 *     HTTP/1.1 404 Not Found
 *     {
 *       "error": "UserNotFound"
 *     }
 */
```


###Let's generate the documentation with the command bellow:



```
"apidoc -i myapp/ -o apidoc/ -t mytemplate/"
```



We need to pass in the command three arguments, first the folder where we can search the comments, second the output and in the end if we make a template the path to template, the final result is the image below:

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/h4dbhol10xri3kac2nfh.JPG)

This is my first post on dev.to, I hope it was of any help, any questions or suggestions just comment below!

 ![Alt Text](https://media.giphy.com/media/3o6fJ1l3Wr1ugMu1Rm/giphy.gif)