npm package: @reportfy/apm
Description: Pacote para utilização de apm do reportfy.com.br
Author: Reportfy
Latest version: 1.9.1

# @reportfy/apm
[![npm version](https://img.shields.io/npm/v/@reportfy/apm.svg?style=flat-square)](https://www.npmjs.org/package/@reportfy/apm)
[![install size](https://packagephobia.now.sh/badge?p=@reportfy/apm)](https://packagephobia.now.sh/result?p=@reportfy/apm)
[![npm downloads](https://img.shields.io/npm/dm/@reportfy/apm.svg?style=flat-square)](http://npm-stat.com/charts.html?package=@reportfy/apm)


![reportfy](https://reportfy.com.br/images/logo-dark.png)


Apm para clientes backend com uso de node.js.

> Sobre reportfy: [clique aqui](https://reportfy.com.br/)

## Sobre a apm.
- [Instalação](#instalação)
- [Configuração](#configuração)
    - [Chamadas de api da aplicação.](#api)
    - [Logs de aplicação](#logs)
    - [Erros costomizado](#custom)


## instalação

Usando npm:

```bash
$ npm install @reportfy/apm --save
```

Usando yarn:

```bash
$ yarn add @reportfy/apm
```

## Configuração

Para configuração é necessário acessar o [sistema da reporfy](https://app.reportfy.com.br) e
criar sua APM, com isso terá o token para integração do sdk.

Após a instalação do seu sdk no seu ```package.json``` iremos para iniciar o projeto.

```js
const { init } = require('@reportfy/apm')

init({
    key: 'sua_chave_aqui',
    environment: 'development',
    accessKey: 'access_key_workspace', 
    secretKey: 'secret_key_workspace',
    log: false,
    tracing: false
})

```

 - [x] O campo ```key``` é obrigatório para que seus logs e erros de aplicação sejam enviados para [reportfy](https://reportfy.com.br).
  -[x] O campo ```accessKey``` é obrigatório, chave secreta para leitura de dados que contém criptografia da sua área de trabalho(workspace).
  -[x] O campo ```accessKey``` é obrigatório, chave secreta para leitura de dados que contém criptografia da sua área de trabalho(workspace).
 - [x] O campo ```environment``` é opcional, ele serve para identificar os **logs, issues, handler e tracing** do seu ambiente. Por **default** a ````.environment ```` é development. 
 - [x] O campo ```tracing``` é opcional, ele serve para realizar **tracing http** da sua api. Por **default** a ````tracing ```` é **false**.
 - [x] O campo ```log``` é opcional, ele serve para realizar **logs** da sua aplicação usando a função console.log. Por **default** a ````log```` é **false**.


<h3 style="color:red;">Observação:</h3>

Caso queira desconsiderar os erros da sua aplicação, basta informar o ```environment``` com o valor `tester`.

## Api

O [reportfy](https://reportfy.com.br) é compatível com os seguintes frameworks:

 * [Framework express](https://expressjs.com/)
 * [Framework nestJS](https://nestjs.com)
 * [Framework koa](https://koajs.com/)
 * [Framework HapiJS](https://hapi.dev/)
 * [Framework Restify](http://restify.com/)
 * [Framework AdonisJS](https://adonisjs.com/)
 * [Framework Sails](https://sailsjs.com/)


Segue os exemplos abaixo:


### Express
Exemplo base para criação de uma api no framework **express**.

```js
const express = require('express')
const { init } = require('@reportfy/apm')

const app = express()
init({ 
  key: 'sua_chave_aqui', 
  environment: 'development',
  accessKey: 'access_key_workspace',
  secretKey: 'secret_key_workspace'
})

app.use(express.json({}))

const port = process.env.PORT || 3000

app.listen(3000, () => console.log('Aplicão no ar: http://localhost:3000'))
```


### NestJS
Exemplo base para criação de uma api no framework **nestJS**.

```js
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import {  init } from '@reportfy/apm'

init({
  key: 'sua_chave_aqui',
  environment: 'development',
  accessKey: 'access_key_workspace',
  secretKey: 'secret_key_workspace'
})

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

```


### Koa
Exemplo base para criação de uma api no framework **koa**.

```js
const Koa = require('koa');
const koaBody = require('koa-body');
const app = new Koa();
const Router = require('koa-router');

const { init } = require('@reportfy/apm')

init({
  key: 'sua_chave_aqui',
  environment: 'development',
  accessKey: 'access_key_workspace',
  secretKey: 'secret_key_workspace'
})

app.use(koaBody());


// Prefix all routes with: /books
const router = new Router({
  prefix: '/api'
});


router.get('/user', (ctx, next) => {
  ctx.body = {name: 'hello world'}
  next();
});

// Use the Router on the sub route /books
app.use(router.routes());

app.listen(3000);

module.exports = app

```
### AdonisJS
Exemplo base para criação de uma api no framework **adonisJS**.

```js
import 'reflect-metadata'
import sourceMapSupport from 'source-map-support'
import { Ignitor } from '@adonisjs/core/build/standalone'

import { init } from '@reportfy/apm'

init({
  key: 'sua_chave_aqui',
  environment: 'development',
  accessKey: 'access_key_workspace',
  secretKey: 'secret_key_workspace'
})

sourceMapSupport.install({ handleUncaughtExceptions: false })

new Ignitor(__dirname)
        .httpServer()
        .start()

```

### HapiJS
Exemplo base para criação de uma api no framework **HapiJS**.

```js
const Hapi = require('@hapi/hapi')
const { init }  = require('@reportfy/apm')

init({
  key: 'sua_chave_aqui',
  environment: 'development',
  accessKey: 'access_key_workspace',
  secretKey: 'secret_key_workspace'
})

const server = Hapi.server({
  port: 3000,
  host: 'localhost'
});

server.route({
  method: 'POST',
  path: '/api/user',
  handler: (request, reply) => {
    return request.payload
  }
});

server.start();

module.exports = server
```

### RestifyJS
Exemplo base para criação de uma api no framework **RestifyJS**.

```js
const restify = require('restify');
const { init } = require('@reportfy/apm')

init({
  key: 'sua_chave_aqui',
  environment: 'development',
  accessKey: 'access_key_workspace',
  secretKey: 'secret_key_workspace'
})

const server = restify.createServer();

server.get('/api/user', (req, res) => {
  return res.send()
});

server.post('/api/user', (req, res) => {
  return res.send()
});

server.listen(3000)

module.exports = server;
```

### Sails
Exemplo base para criação de uma api no framework **Sails**.

```js
process.chdir(__dirname);

const { init } = require('@reportfy/apm')

init({
  key: 'sua_chave_aqui',
  environment: 'development',
  accessKey: 'access_key_workspace',
  secretKey: 'secret_key_workspace'
})


// Attempt to import `sails` dependency, as well as `rc` (for loading `.sailsrc` files).
var sails;
var rc;
try {
  sails = require('sails');
  rc = require('sails/accessible/rc');
} catch (err) {
  console.error('Encountered an error when attempting to require(\'sails\'):');
  console.error(err.stack);
  console.error('--');
  console.error('To run an app using `node app.js`, you need to have Sails installed');
  console.error('locally (`./node_modules/sails`).  To do that, just make sure you\'re');
  console.error('in the same directory as your app and run `npm install`.');
  console.error();
  console.error('If Sails is installed globally (i.e. `npm install -g sails`) you can');
  console.error('also run this app with `sails lift`.  Running with `sails lift` will');
  console.error('not run this file (`app.js`), but it will do exactly the same thing.');
  console.error('(It even uses your app directory\'s local Sails install, if possible.)');
  return;
}//-•


// Start server
sails.lift(rc('sails'));

```

## Logs

Para que o [reportfy](https://reportfy.com.br) identifique os logs do seu sistema,
necessita de alguns parâmetros, que são:


- [x] ```type``` é uma forma de identificar qual seria o error. Temos os seguintes ```info```, ```warn``` e ```error```.
- [x] ```message``` é uma forma de salvar a mensagem do log, nesse campo ele receberá os tipos ```boolean```, ```string```, ```array``` e ```object```.
- [x] ```tag``` é uma forma de identificar o log, esse campo é uma forma de fazer **tracing** dos seus logs.


Para utilizar os logs na aplicação, segue o exemplo abaixo:

```js
console.log({ 
  type: 'info',
  message: 'hello world',
  tag: 'hello'
})
```

A saída esperado no terminal, é:

```shell
@reportfy.log hello world
```

## custom
Para que o [reportfy](https://reportfy.com.br) gerencia o seus erros costomizados ele necessita de alguns parâmetros, que são:


- [x] ```origin``` é uma forma de identificar em qual momento partiu seria o error.
- [x] ```message``` é uma forma de salvar a mensagem do erro costomizado, nesse campo ele receberá os tipos ```string```.
- [x] ```stack``` é uma forma de identificar o a stack tracer do seu erro, nesse campo ele receberá os tipos ```boolean```, ```string```, ```array``` e ```object```.


Para utilizar o erro costomizado na sua aplicação, segue o exemplo abaixo:

```js
const reportfyApm = require('@reportfy/apm')

const { customError } = reportfyApm.init({
  key: 'sua_chave_aqui', 
  env: 'development',
  accessKey: 'access_key_workspace',
  secretKey: 'secret_key_workspace'
})

customError({
  origin: "origin_aqui",
  message: "message_aqui",
  stack: "stack_aqui"
})
```

Esse erro é salvo no reportfy como tipo *events*.