DeepSeek prompt medir desempenho api em typescript

benchmark.ts

# Medindo Desempenho de API em TypeScript

Para medir o desempenho de uma API em TypeScript, existem várias abordagens e ferramentas que você pode utilizar. Aqui estão algumas das principais técnicas:

## 1. Usando o módulo `performance` do Node.js

```typescript
import { performance } from 'perf_hooks';

async function measureApiCall() {
  const startTime = performance.now();
  
  // Sua chamada de API aqui
  await fetch('https://api.example.com/data');
  
  const endTime = performance.now();
  const duration = endTime - startTime;
  
  console.log(`A chamada da API levou ${duration} milissegundos`);
}

measureApiCall();
```

## 2. Criando um decorator para medição

```typescript
function measurePerformance(
  target: any,
  propertyKey: string,
  descriptor: PropertyDescriptor
) {
  const originalMethod = descriptor.value;

  descriptor.value = async function (...args: any[]) {
    const start = performance.now();
    const result = await originalMethod.apply(this, args);
    const end = performance.now();
    
    console.log(`Método ${propertyKey} executado em ${end - start} ms`);
    return result;
  };

  return descriptor;
}

class ApiService {
  @measurePerformance
  async fetchData() {
    // Implementação da chamada da API
    return await fetch('https://api.example.com/data');
  }
}
```

## 3. Usando bibliotecas especializadas

### Artillery (para testes de carga)
```bash
npm install -g artillery
```

Crie um arquivo de configuração `load-test.yml`:
```yaml
config:
  target: "https://api.example.com"
  phases:
    - duration: 60
      arrivalRate: 10
scenarios:
  - flow:
      - get:
          url: "/data"
```

Execute com:
```bash
artillery run load-test.yml
```

### Autocannon
```typescript
import autocannon from 'autocannon';

autocannon({
  url: 'https://api.example.com',
  connections: 10, // Número de conexões concorrentes
  duration: 10,    // Duração do teste em segundos
  requests: [
    {
      method: 'GET',
      path: '/data'
    }
  ]
}, console.log);
```

## 4. Monitoramento contínuo

Para produção, considere usar:

- **APM (Application Performance Monitoring)**:
  - New Relic
  - Datadog
  - AppDynamics
  - Elastic APM

- **Logging distribuído**:
  - OpenTelemetry
  - Jaeger
  - Zipkin

## 5. Métricas importantes para monitorar

1. **Tempo de resposta**: Latência média, p95, p99
2. **Taxa de erros**: Porcentagem de requisições falhas
3. **Taxa de requisições**: RPS (Requests Per Second)
4. **Uso de recursos**: CPU, memória, I/O
5. **Throughput**: Dados transferidos por segundo

## Exemplo completo com TypeScript e Express

```typescript
import express, { Request, Response, NextFunction } from 'express';
import { performance } from 'perf_hooks';

const app = express();

// Middleware para medir o desempenho
app.use((req: Request, res: Response, next: NextFunction) => {
  const start = performance.now();
  
  res.on('finish', () => {
    const end = performance.now();
    const duration = end - start;
    console.log(`${req.method} ${req.url} - ${duration.toFixed(2)}ms`);
  });
  
  next();
});

app.get('/api/data', async (req: Request, res: Response) => {
  // Simula processamento
  await new Promise(resolve => setTimeout(resolve, 100));
  res.json({ data: 'example' });
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});
```

Lembre-se de que a medição de desempenho deve ser feita em ambientes controlados (para benchmarks) e em produção (para monitoramento contínuo), com cuidado para não afetar o desempenho real da aplicação com as próprias ferramentas de medição.