# 📊 Performance Monitor Logger - Complete Guide

## Instalação

```bash
npm i performance-monitor-logger --save-dev
```

## Exemplo de Uso

### tela.service.ts

```typescript
import { Injectable } from "@angular/core";
import { PerformanceMonitor } from "performance-monitor-logger"; //<--

@Injectable({ providedIn: "root" })
export class ExemploService {
  constructor() {}

  @PerformanceMonitor() //<--
  async buscarUsuarios() {
    try {
      const usuarios = await this.http.get("/api/usuarios").toPromise();
      return usuarios;
    } catch (error) {
      throw error;
    }
  }

  @PerformanceMonitor() //<--
  async salvarUsuario(usuario: any) {
    try {
      const resultado = await this.http.post("/api/usuarios", usuario).toPromise();
      return resultado;
    } catch (error) {
      throw error;
    }
  }
}
```

### tela.component.ts

```typescript
import { Injectable } from "@angular/core";
import { GlobalPerformanceLogger } from "performance-monitor-logger"; //<--


  constructor() {
    GlobalPerformanceLogger.injectMonitorButton(); //<--
  }


```

### app.module.ts

```typescript
import { PerformanceMonitorInterceptor } from "performance-monitor-logger"; //<--

@NgModule({
  providers: [
    ...{
      provide: HTTP_INTERCEPTORS, //<--
      useClass: PerformanceMonitorInterceptor, //<--
      multi: true, //<--
    },
  ],
})
export class AppModule {}
```

## Modo Auto‑Instrumentação (sem decorators) – monitorar `setService(...)`

Em cenários onde serviços são registrados via `setService(this)` (ex.: packs como `packTela`, `packDescricoes`, etc.), você pode habilitar o monitoramento automaticamente, sem usar `@PerformanceMonitor()` em cada método.

O logger disponibiliza três utilitários:

- `GlobalPerformanceLogger.hookSetService(target, label?, options?)`
- `GlobalPerformanceLogger.hookSetServiceBulk(targetsMap, options?)`
- `GlobalPerformanceLogger.hookSetServiceNamespace(root, options?)`

Esses hooks substituem a função `setService` do alvo e instrumentam a instância passada, envolvendo todos os métodos públicos para coleta de métricas com segurança e alto desempenho.

### Opções principais

- `exclude`: filtros de métodos a ignorar (padrão exclui `constructor`).
- `nameTransform`: função para nomear operações (ex.: `packTela.metodo`).
- `include`/`exclude` (InstrumentOptions): filtros por nome do método.
- `includeObjects`/`excludeObjects` (Namespace): filtros por caminho do objeto em varredura.
- `maxWalkDepth`: profundidade máxima ao varrer namespaces.

### Exemplo 1 — Hook em vários packs com uma chamada | SUGESTÃO |

```typescript
import { GlobalPerformanceLogger } from "performance-monitor-logger";

// Agrupe os packs em um objeto literal
const packs = {
  packTela,
  packDescricoes,
  packCalculo,
  packFormulas,
  packPrecograoInterno,
  packProcedimentos,
  gravaFixacao,
  gravaProgfixacao,
  gravaDevolucao,
  packFornecedor,
  packTransgenicoInterna,
  packMaxeditorTela,
  packClifor,
  packParametros,
  packVetor,
  packQualidade,
  packRecexpgrao,
  packImpostotela,
  packFuncoes,
  packMestra,
  packPropostanegocio,
  packFavorecidos,
  functionService: this.functionService,
  modelLov: this.modelLov,
  packArquivoutils: this.packArquivoutils,
};

// Aplica o hook de forma bulk
GlobalPerformanceLogger.hookSetServiceBulk(packs, {
  exclude: ["constructor"],
  nameTransform: (name, path) => `${path?.[0] || "service"}.${name}`,
});

// As chamadas existentes a setService(...) continuam funcionando normalmente,
// mas agora cada serviço passado será instrumentado automaticamente.
```

### Exemplo 2 — Varredura de namespace

```typescript
import { GlobalPerformanceLogger } from "performance-monitor-logger";

const packs = {
  /* mesmo objeto do exemplo anterior */
};

GlobalPerformanceLogger.hookSetServiceNamespace(packs, {
  includeObjects: [/./],
  maxWalkDepth: 0,
  exclude: ["constructor"],
  labelFromPath: (p) => p[0],
  nameTransform: (name, path) => `${path?.[0] || "service"}.${name}`,
});
```

### Exemplo 3 — Por objeto individual

```typescript
import { GlobalPerformanceLogger } from "performance-monitor-logger";

GlobalPerformanceLogger.hookSetService(packTela, "packTela");
GlobalPerformanceLogger.hookSetService(packDescricoes, "packDescricoes");
// ... e assim por diante
```

### Como os nomes das operações são formados

- Por padrão, cada método instrumentado recebe o nome `label.metodo`.
- O `label` vem do argumento passado ou do caminho calculado no namespace.
- Personalize com `nameTransform`, por exemplo: `name => 'srv:' + name`.

### Interoperabilidade com o modo decorator

- Você pode misturar os dois modos. Métodos anotados com `@PerformanceMonitor()` continuam medidos.
- O hook evita duplicação e preserva `toString()` para compatibilidade com regex.
- O `constructor` é sempre ignorado por segurança.

## Resultado esperado:

### No console você verá:

![Logs](./projects/performance-monitor-logger/src/lib/img/1.png)
![análise detalhada](./projects/performance-monitor-logger/src/lib/img/2.png)
![relatório de performance](./projects/performance-monitor-logger/src/lib/img/3.png)
![relatório de requisição](./projects/performance-monitor-logger/src/lib/img/4.png)