Monitoramento de IA em Produção: detectar problemas antes dos usuários reclamarem

Sistema de IA em produção sem monitoramento = dirigir vendado.

Problemas invisíveis:

• IA respondendo errado há 3 dias (ninguém percebeu)
• Custo disparou R$ 2.500 → R$ 9.800 (só descobriu na fatura)
• Latência 15s (usuários abandonaram, não reclamaram)
• 40% das chamadas falhando (erro silencioso)

Caso real: SaaS de atendimento (180 clientes) ficou 8h com IA quebrada:

• Sistema retornava erro 500
• Clientes abriram 47 tickets
• 12 cancelamentos (R$ 3.588 MRR perdido)
• Causa: Rate limit da API atingido (não monitoravam)

Solução: Monitoramento inteligente detecta problemas antes dos usuários.

Este artigo mostra o que monitorar e como.

Categorias de métricas

1. Disponibilidade (uptime)

Métrica básica: Sistema está no ar?

O que medir:

• Uptime %: 99,9% = 43min downtime/mês (aceitável)
• MTBF (Mean Time Between Failures): Tempo médio entre falhas
• MTTR (Mean Time To Recovery): Tempo médio para recuperar

Como monitorar:

// lib/monitoring/health-check.ts
import * as Sentry from '@sentry/node'

export async function healthCheck() {
  const checks = {
    database: false,
    redis: false,
    ai_api: false
  }

  // Verifica banco de dados
  try {
    await db.$queryRaw`SELECT 1`
    checks.database = true
  } catch (error) {
    Sentry.captureException(error)
  }

  // Verifica Redis
  try {
    await redis.ping()
    checks.redis = true
  } catch (error) {
    Sentry.captureException(error)
  }

  // Verifica API da IA
  try {
    const response = await fetch('https://api.anthropic.com/v1/health', {
      headers: { 'x-api-key': process.env.ANTHROPIC_API_KEY }
    })
    checks.ai_api = response.ok
  } catch (error) {
    Sentry.captureException(error)
  }

  const allHealthy = Object.values(checks).every(v => v === true)

  return {
    status: allHealthy ? 'healthy' : 'degraded',
    checks,
    timestamp: new Date().toISOString()
  }
}

// API endpoint
app.get('/health', async (req, res) => {
  const health = await healthCheck()

  res
    .status(health.status === 'healthy' ? 200 : 503)
    .json(health)
})

Monitoramento externo (pinga de fora para dentro):

# uptimerobot.com ou betteruptime.com
monitors:
  - name: "API Health Check"
    url: "https://api.suaempresa.com/health"
    interval: 60 # Segundos
    alert_contacts:
      - email: ops@suaempresa.com
      - sms: +5511999999999
      - slack: https://hooks.slack.com/services/...

  - name: "IA Chat Widget"
    url: "https://chat.suaempresa.com"
    keyword: "Conectado" # Verifica se palavra aparece na página
    interval: 300 # 5min

Custo: R$ 0-200/mês (UptimeRobot free tier funciona bem).

2. Performance (latência)

Por que importa: Usuário abandona se demorar mais de 3s.

O que medir:

• P50 latência: 50% das respostas são mais rápidas que X
• P95 latência: 95% das respostas são mais rápidas que Y
• P99 latência: 99% das respostas são mais rápidas que Z

Exemplo real:

• P50: 1,2s (metade responde em até 1,2s) ✅
• P95: 3,8s (95% respondem até 3,8s) ⚠️
• P99: 12,5s (1% demora mais de 12s) ❌ Problema!

Como monitorar:

// lib/monitoring/latency.ts
import { performance } from 'perf_hooks'

export async function measureAICall<T>(
  fn: () => Promise<T>,
  metadata: { userId: string, query: string }
): Promise<{ result: T, latency: number }> {
  const start = performance.now()

  try {
    const result = await fn()
    const latency = performance.now() - start

    // Log métrica
    await logMetric({
      type: 'ai_call_latency',
      latency,
      ...metadata,
      timestamp: Date.now()
    })

    // Alerta se latência muito alta
    if (latency mais de 10000) { // mais de 10s
      await notifySlack({
        channel: '#ai-alerts',
        text: `⚠️ High latency: ${latency.toFixed(0)}ms\nUser: ${metadata.userId}\nQuery: ${metadata.query}`
      })
    }

    return { result, latency }

  } catch (error) {
    const latency = performance.now() - start

    // Log erro
    await logMetric({
      type: 'ai_call_error',
      latency,
      error: error.message,
      ...metadata
    })

    throw error
  }
}

// Uso
const { result, latency } = await measureAICall(
  () => anthropic.messages.create({ ... }),
  { userId: '123', query: 'Como fazer X?' }
)

console.log(`Resposta em ${latency.toFixed(0)}ms`)

Dashboard de latência (SQL para DataDog/Grafana):

-- P50, P95, P99 por hora
SELECT
  DATE_TRUNC('hour', timestamp) as hour,
  PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY latency) as p50,
  PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY latency) as p95,
  PERCENTILE_CONT(0.99) WITHIN GROUP (ORDER BY latency) as p99,
  COUNT(*) as total_calls
FROM ai_metrics
WHERE
  type = 'ai_call_latency'
  AND timestamp >= NOW() - INTERVAL '24 hours'
GROUP BY hour
ORDER BY hour DESC;

Gráfico:

Latência (ms)
↑
15000 |                                            ▲ P99
      |                                        ▲
10000 |                              ▲    ▲
      |                          ▲
 5000 |           ━━━━━━━━━━━━━              ━━━ P95
      |   ━━━━━━━                                ━━━
 2000 |━━━                                          P50
      |
    0 +────────────────────────────────────────────→
      8h   10h   12h   14h   16h   18h   20h   22h

Ação: Pico às 16h (horário de rush) → Adicionar mais servidores nesse horário (auto-scaling).

3. Taxa de erro

O que medir:

• 4xx erros: Erro do usuário (query inválida)
• 5xx erros: Erro do sistema (bug, API down)
• Rate limit: Atingiu limite de API

Como monitorar:

// lib/monitoring/errors.ts
export async function trackAICall(
  userId: string,
  query: string,
  fn: () => Promise<any>
) {
  try {
    const result = await fn()

    await logMetric({
      type: 'ai_call_success',
      userId,
      query
    })

    return result

  } catch (error) {
    // Classifica erro
    let errorType: string

    if (error.status === 429) {
      errorType = 'rate_limit'
    } else if (error.status >= 400 && error.status menos de 500) {
      errorType = 'client_error'
    } else if (error.status >= 500) {
      errorType = 'server_error'
    } else {
      errorType = 'unknown'
    }

    await logMetric({
      type: 'ai_call_error',
      errorType,
      errorMessage: error.message,
      userId,
      query
    })

    // Alerta crítico se rate limit ou server error
    if (['rate_limit', 'server_error'].includes(errorType)) {
      await notifySlack({
        channel: '#ai-critical',
        text: `🚨 Critical error: ${errorType}\n${error.message}`
      })
    }

    throw error
  }
}

Dashboard:

-- Taxa de erro por hora
SELECT
  DATE_TRUNC('hour', timestamp) as hour,
  COUNT(*) FILTER (WHERE type = 'ai_call_error') as errors,
  COUNT(*) FILTER (WHERE type = 'ai_call_success') as successes,
  ROUND(
    100.0 * COUNT(*) FILTER (WHERE type = 'ai_call_error') /
    NULLIF(COUNT(*), 0),
    2
  ) as error_rate_pct
FROM ai_metrics
WHERE timestamp >= NOW() - INTERVAL '24 hours'
GROUP BY hour
ORDER BY hour DESC;

Resultado:

hour               | errors | successes | error_rate_pct
-------------------+--------+-----------+---------------
2026-09-27 22:00   |      3 |       487 |           0.61
2026-09-27 21:00   |      1 |       512 |           0.19
2026-09-27 20:00   |      8 |       445 |           1.77  ⚠️
2026-09-27 19:00   |     12 |       398 |           2.93  ❌

Alerta: Se error_rate mais de 2% → Investigar.

4. Qualidade de output

Problema: IA responde rápido, mas resposta está errada.

Como medir:

A) Feedback explícito (usuário avalia)

// components/FeedbackWidget.tsx
export function FeedbackWidget({ responseId }: { responseId: string }) {
  async function submitFeedback(helpful: boolean) {
    await fetch('/api/feedback', {
      method: 'POST',
      body: JSON.stringify({
        responseId,
        helpful,
        timestamp: Date.now()
      })
    })
  }

  return (
    <div className="flex gap-2 mt-2">
      <p className="text-sm">Essa resposta foi útil?</p>
      <button onClick={() => submitFeedback(true)} className="text-green-600">
        👍 Sim
      </button>
      <button onClick={() => submitFeedback(false)} className="text-red-600">
        👎 Não
      </button>
    </div>
  )
}

Dashboard:

-- % respostas úteis
SELECT
  DATE(created_at) as day,
  COUNT(*) FILTER (WHERE helpful = true) as thumbs_up,
  COUNT(*) FILTER (WHERE helpful = false) as thumbs_down,
  ROUND(
    100.0 * COUNT(*) FILTER (WHERE helpful = true) / COUNT(*),
    1
  ) as helpful_pct
FROM feedback
WHERE created_at >= NOW() - INTERVAL '30 days'
GROUP BY day
ORDER BY day DESC;

Meta: mais de 80% thumbs up.

B) Feedback implícito (comportamento)

// lib/monitoring/implicit-feedback.ts
export async function trackUserBehavior(
  userId: string,
  responseId: string,
  action: 'copied' | 'edited' | 'discarded' | 'regenerated'
) {
  await logMetric({
    type: 'user_behavior',
    userId,
    responseId,
    action,
    timestamp: Date.now()
  })

  // Interpreta ação
  const qualitySignal = {
    copied: 'good',      // Usou resposta = boa
    edited: 'ok',        // Ajustou resposta = ok, mas não perfeita
    discarded: 'bad',    // Descartou = ruim
    regenerated: 'bad'   // Pediu nova = ruim
  }[action]

  await db.responseQuality.create({
    data: { responseId, signal: qualitySignal }
  })
}

Dashboard:

-- Distribuição de ações
SELECT
  action,
  COUNT(*) as count,
  ROUND(100.0 * COUNT(*) / SUM(COUNT(*)) OVER (), 1) as pct
FROM user_behavior
WHERE timestamp >= NOW() - INTERVAL '7 days'
GROUP BY action;

Resultado:

action      | count | pct
------------+-------+------
copied      |  2487 | 68.3  ✅ Boa
edited      |   814 | 22.4  ⚠️
discarded   |   198 |  5.4  ❌
regenerated |   142 |  3.9  ❌

Interpretação: 68% copia direto (ótimo), 9% descarta/regenera (precisa melhorar).

C) Validação automática (assertions)

Para casos específicos (ex: extrair dados estruturados):

// lib/monitoring/validation.ts
export async function extractContractData(text: string) {
  const response = await anthropic.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    messages: [{
      role: 'user',
      content: `Extraia dados do contrato:\n\n${text}\n\nRetorne JSON com: cliente, valor, data_inicio, data_fim`
    }]
  })

  const data = JSON.parse(response.content[0].text)

  // Validações automáticas
  const errors = []

  if (!data.cliente || data.cliente.length menos de 3) {
    errors.push('Cliente inválido')
  }

  if (!data.valor || data.valor <= 0) {
    errors.push('Valor inválido')
  }

  if (!data.data_inicio || !isValidDate(data.data_inicio)) {
    errors.push('Data início inválida')
  }

  if (!data.data_fim || new Date(data.data_fim) <= new Date(data.data_inicio)) {
    errors.push('Data fim inválida')
  }

  // Log validação
  await logMetric({
    type: 'extraction_validation',
    success: errors.length === 0,
    errors,
    data
  })

  if (errors.length mais de 0) {
    await notifySlack({
      channel: '#ai-quality',
      text: `⚠️ Extração com erros:\n${errors.join('\n')}`
    })
  }

  return { data, errors }
}

Dashboard:

-- Taxa de sucesso em validações
SELECT
  DATE(timestamp) as day,
  COUNT(*) FILTER (WHERE success = true) as valid,
  COUNT(*) FILTER (WHERE success = false) as invalid,
  ROUND(100.0 * COUNT(*) FILTER (WHERE success = true) / COUNT(*), 1) as success_rate
FROM extraction_validation
WHERE timestamp >= NOW() - INTERVAL '30 days'
GROUP BY day
ORDER BY day DESC;

5. Custo

Por que monitorar: Custo pode disparar silenciosamente.

Como calcular custo por chamada:

// lib/monitoring/cost.ts
const PRICING = {
  'claude-3-5-sonnet-20241022': {
    input: 3.00 / 1_000_000,  // $3 por 1M tokens
    output: 15.00 / 1_000_000  // $15 por 1M tokens
  },
  'gpt-4-turbo': {
    input: 10.00 / 1_000_000,
    output: 30.00 / 1_000_000
  }
}

export async function calculateCost(
  model: string,
  inputTokens: number,
  outputTokens: number
) {
  const pricing = PRICING[model]

  const inputCost = inputTokens * pricing.input
  const outputCost = outputTokens * pricing.output
  const totalCost = inputCost + outputCost

  // Log custo
  await logMetric({
    type: 'ai_call_cost',
    model,
    inputTokens,
    outputTokens,
    inputCost,
    outputCost,
    totalCost,
    timestamp: Date.now()
  })

  return {
    inputCost,
    outputCost,
    totalCost,
    totalCostBRL: totalCost * 5.50 // Taxa câmbio
  }
}

// Uso
const response = await anthropic.messages.create({ ... })

await calculateCost(
  'claude-3-5-sonnet-20241022',
  response.usage.input_tokens,
  response.usage.output_tokens
)

Dashboard de custos:

-- Custo diário
SELECT
  DATE(timestamp) as day,
  SUM(total_cost) as total_usd,
  SUM(total_cost) * 5.50 as total_brl,
  COUNT(*) as total_calls,
  AVG(total_cost) as avg_cost_per_call
FROM ai_cost_metrics
WHERE timestamp >= NOW() - INTERVAL '30 days'
GROUP BY day
ORDER BY day DESC;

Resultado:

day        | total_usd | total_brl | total_calls | avg_cost_per_call
-----------+-----------+-----------+-------------+------------------
2026-09-27 |    18.42  |  101.31   |     2487    |       0.0074
2026-09-26 |    22.88  |  125.84   |     3012    |       0.0076
2026-09-25 |    67.32  |  370.26   |     8421    |       0.0080  ⚠️

Alerta: Dia 25 teve pico de custo (R$ 370 vs média R$ 115). Por quê?

-- Investigar dia 25
SELECT
  user_id,
  COUNT(*) as calls,
  SUM(total_cost) as cost_usd
FROM ai_cost_metrics
WHERE DATE(timestamp) = '2026-09-25'
GROUP BY user_id
ORDER BY cost_usd DESC
LIMIT 10;

Descoberta: User #842 fez 1.847 chamadas (bug em loop). Resolvido.

6. Uso (adoção)

O que medir:

• DAU (Daily Active Users): Usuários únicos/dia
• WAU (Weekly Active Users)
• MAU (Monthly Active Users)
• Stickiness: DAU/MAU (quanto maior, mais engajados)

-- DAU, WAU, MAU
SELECT
  COUNT(DISTINCT user_id) FILTER (
    WHERE timestamp >= NOW() - INTERVAL '1 day'
  ) as dau,
  COUNT(DISTINCT user_id) FILTER (
    WHERE timestamp >= NOW() - INTERVAL '7 days'
  ) as wau,
  COUNT(DISTINCT user_id) FILTER (
    WHERE timestamp >= NOW() - INTERVAL '30 days'
  ) as mau,
  ROUND(
    100.0 *
    COUNT(DISTINCT user_id) FILTER (WHERE timestamp >= NOW() - INTERVAL '1 day') /
    NULLIF(COUNT(DISTINCT user_id) FILTER (WHERE timestamp >= NOW() - INTERVAL '30 days'), 0),
    1
  ) as stickiness_pct
FROM ai_metrics;

Resultado:

dau  | wau  | mau  | stickiness_pct
-----+------+------+---------------
 142 |  287 |  412 |          34.5

Interpretação: 34,5% stickiness (142 usam diariamente de 412 total mensais). Razoável (meta: mais de 40%).

Alertas inteligentes

Problema: Muito alerta = ignora. Pouco alerta = perde problema.

Estratégia: Alertas em 3 níveis.

Nível 1: Info (Slack, não acorda ninguém)

// lib/monitoring/alerts.ts
export async function infoAlert(message: string) {
  await notifySlack({
    channel: '#ai-info',
    text: `ℹ️ ${message}`
  })
}

// Exemplo: Uso alto (mas não crítico)
if (dailyCost mais de 150 && dailyCost menos de 250) {
  await infoAlert(`Custo hoje: R$ ${dailyCost.toFixed(2)} (acima da média)`)
}

Nível 2: Warning (Slack + email)

export async function warningAlert(message: string) {
  await notifySlack({
    channel: '#ai-warnings',
    text: `⚠️ ${message}`,
    mention: '@channel'
  })

  await sendEmail({
    to: 'ops@empresa.com',
    subject: '[AI Warning] ' + message,
    body: message
  })
}

// Exemplo: Taxa de erro subiu
if (errorRate mais de 2 && errorRate menos de 5) {
  await warningAlert(`Taxa de erro: ${errorRate.toFixed(1)}% (normal: menos de 2%)`)
}

Nível 3: Critical (Slack + email + SMS + PagerDuty)

export async function criticalAlert(message: string) {
  await notifySlack({
    channel: '#ai-critical',
    text: `🚨 CRITICAL: ${message}`,
    mention: '@here'
  })

  await sendEmail({
    to: ['ops@empresa.com', 'cto@empresa.com'],
    subject: '[AI CRITICAL] ' + message,
    body: message,
    priority: 'high'
  })

  await sendSMS({
    to: '+5511999999999',
    text: `AI CRITICAL: ${message}`
  })

  await pagerDuty.trigger({
    title: 'AI System Critical',
    description: message,
    severity: 'critical'
  })
}

// Exemplo: Sistema down
if (uptimeCheck.status === 'down') {
  await criticalAlert('Sistema de IA fora do ar há 5 minutos')
}

// Exemplo: Taxa de erro muito alta
if (errorRate mais de 10) {
  await criticalAlert(`Taxa de erro crítica: ${errorRate.toFixed(1)}%`)
}

Regras de alerta:

// config/alert-rules.ts
export const ALERT_RULES = {
  error_rate: {
    info: 1.5,      // mais de 1.5% → info
    warning: 3.0,   // mais de 3% → warning
    critical: 10.0  // mais de 10% → critical
  },
  latency_p95: {
    info: 3000,     // mais de 3s → info
    warning: 5000,  // mais de 5s → warning
    critical: 10000 // mais de 10s → critical
  },
  daily_cost: {
    info: 200,      // > R$ 200 → info
    warning: 400,   // > R$ 400 → warning
    critical: 800   // > R$ 800 → critical
  },
  uptime: {
    critical: 'down' // Sistema down → critical imediatamente
  }
}

Dashboard executivo

O que CEO/CTO querem ver (atualizado diário):

// lib/monitoring/executive-dashboard.ts
export async function generateExecutiveDashboard() {
  const last24h = Date.now() - 24 * 60 * 60 * 1000
  const last7d = Date.now() - 7 * 24 * 60 * 60 * 1000

  // Consultas
  const [
    uptime24h,
    totalCalls24h,
    errorRate24h,
    avgLatency24h,
    cost24h,
    cost7d,
    activeUsers24h,
    helpfulRate7d
  ] = await Promise.all([
    calculateUptime(last24h),
    countCalls(last24h),
    calculateErrorRate(last24h),
    calculateAvgLatency(last24h),
    calculateCost(last24h),
    calculateCost(last7d),
    countActiveUsers(last24h),
    calculateHelpfulRate(last7d)
  ])

  return {
    // Disponibilidade
    uptime: `${uptime24h.toFixed(2)}%`,
    status: uptime24h >= 99.9 ? '✅ Saudável' : '⚠️ Degradado',

    // Volume
    calls_24h: totalCalls24h.toLocaleString('pt-BR'),
    active_users_24h: activeUsers24h,

    // Performance
    avg_latency: `${(avgLatency24h / 1000).toFixed(1)}s`,
    error_rate: `${errorRate24h.toFixed(2)}%`,

    // Qualidade
    helpful_rate: `${helpfulRate7d.toFixed(1)}%`,

    // Custo
    cost_24h: `R$ ${cost24h.toFixed(2)}`,
    cost_7d: `R$ ${cost7d.toFixed(2)}`,
    cost_per_call: `R$ ${(cost24h / totalCalls24h).toFixed(4)}`
  }
}

Resultado (enviado por email diário):

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 IA Dashboard - 27/09/2026
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🟢 Status: Saudável
⏰ Uptime 24h: 99.98%

📈 Volume (24h)
   Chamadas: 2.487
   Usuários ativos: 142

⚡ Performance
   Latência média: 1.8s
   Taxa de erro: 0.74%

😊 Qualidade (7d)
   Respostas úteis: 82.3%

💰 Custo
   Hoje: R$ 101,31
   Últimos 7d: R$ 742,88
   Por chamada: R$ 0,0407

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Case real: Chatbot e-commerce

Empresa: Loja online (1.200 pedidos/dia, 18 atendentes).

Sistema: Chatbot IA para dúvidas pré-venda.

Monitoramento implementado (3 semanas):

Semana 1: Métricas básicas

• Uptime monitoring (UptimeRobot)
• Logs centralizados (Logtail)
• Custo por chamada

Descoberta: Taxa de erro 4,2% (8x maior que esperado).

Causa: IA não conseguia acessar produtos fora de estoque (erro 404).

Solução: Tratamento de erro + filtro (só mostra produtos disponíveis).

Resultado: Taxa de erro caiu para 0,8%.

Semana 2: Qualidade de output

• Feedback explícito (👍👎)
• Validação automática (respostas devem ter preço/link)

Descoberta: 28% feedback negativo em perguntas sobre frete.

Causa: Banco de dados de CEPs desatualizado.

Solução: Integração API Correios (dados em tempo real).

Resultado: Feedback negativo caiu para 9%.

Semana 3: Alertas inteligentes

• Alerta se error_rate mais de 2%
• Alerta se custo diário > R$ 300
• Alerta se latência P95 mais de 5s

Resultado: 0 incidentes não detectados (vs 3/semana antes).

Resultados finais (12 semanas):

Métrica	Antes monitoramento	Depois	Variação
Uptime	97,2%	99,94%	+2,8%
Taxa de erro	4,2%	0,6%	-86%
Latência P95	6,8s	2,1s	-69%
Custo/dia	R$ 420	R$ 180	-57%
Feedback positivo	68%	91%	+34%
MTTR (tempo pra resolver)	4,2h	18min	-93%

ROI monitoramento:

• Custo ferramentas: R$ 450/mês (DataDog + UptimeRobot)
• Economia: R$ 7.200/mês (custo API) + R$ 12K/mês (menos retrabalho)
• ROI: 4.178%

Ferramentas recomendadas

Tier 1: Essenciais (R$ 0-500/mês)

Uptime Robot (R$ 0-100/mês):

• Monitoramento uptime externo
• Alertas email/SMS/Slack
• Tier gratuito: 50 monitores, check 5min

Logtail (R$ 0-150/mês):

• Logs centralizados
• Busca rápida
• Tier gratuito: 1GB/mês

Sentry (R$ 0-250/mês):

• Error tracking
• Performance monitoring (APM básico)
• Tier gratuito: 5K erros/mês

Total Tier 1: R$ 0-500/mês.

Tier 2: Avançado (R$ 500-2K/mês)

DataDog (R$ 600-1.5K/mês):

• Logs + APM + Métricas customizadas
• Dashboards poderosos
• Alertas inteligentes

Better Uptime (R$ 200-400/mês):

• Uptime + status page público
• Incident management
• On-call scheduling

Total Tier 2: R$ 800-1.9K/mês.

Tier 3: Enterprise (R$ 3K+/mês)

New Relic (R$ 2K-5K/mês):

• Full observability stack
• AI/ML anomaly detection

PagerDuty (R$ 1K-3K/mês):

• Incident response
• On-call management

Total Tier 3: R$ 3K-8K/mês.

Recomendação:

• Começando: Tier 1 (R$ 0-500/mês)
• Escala (mais de 100 usuários): Tier 2 (R$ 800-1.9K/mês)
• Enterprise (mais de 1000 usuários): Tier 3

Checklist de monitoramento

Setup inicial (1-2 semanas)

• Health check endpoint (/health)
• Uptime monitoring externo (UptimeRobot)
• Logs centralizados (Logtail ou DataDog)
• Error tracking (Sentry)

Métricas técnicas

• Uptime % (meta: mais de 99,9%)
• Latência P50/P95/P99
• Taxa de erro (meta: menos de 2%)
• Custo por chamada

Métricas de qualidade

• Feedback explícito (👍👎)
• Taxa de respostas úteis (meta: mais de 80%)
• Validação automática (se aplicável)

Alertas

• Critical: Sistema down
• Critical: Taxa de erro mais de 10%
• Warning: Taxa de erro mais de 3%
• Warning: Latência P95 mais de 5s
• Info: Custo diário >média +50%

Dashboard

• Dashboard técnico (devs)
• Dashboard executivo (CEO/CTO)
• Email diário com resumo

Investimento

Setup (one-time):

• Implementação métricas: R$ 4-8K (1-2 semanas dev)
• Setup ferramentas: R$ 1-2K

Operação mensal:

• Ferramentas Tier 1: R$ 0-500/mês
• Ferramentas Tier 2: R$ 800-1.9K/mês
• Manutenção (revisar dashboards): R$ 1-2K/mês (tempo alocado)

Total primeiro ano:

• Setup: R$ 5-10K
• Operação: R$ 9,6-46,8K (depende de tier)
• Total: R$ 14,6-56,8K

ROI esperado:

• Redução downtime: 50-80% (menos prejuízo)
• Redução custo API: 30-60% (otimizações baseadas em dados)
• Redução retrabalho: 40-70% (detecta problemas cedo)

Próximos passos

1. Implementar health check básico (/health endpoint)
2. Setup UptimeRobot (monitoramento externo)
3. Adicionar tracking de latência e erros
4. Implementar cálculo de custo por chamada
5. Criar dashboard básico (métricas-chave)
6. Configurar alertas (critical, warning, info)
7. Revisar métricas semanalmente (primeiros 2 meses)
8. Iterar: adicionar métricas conforme necessidade

Lembre-se: Monitorar não é opcional. Sistema sem monitoramento = bomba relógio. Começar simples (Tier 1) e evoluir conforme escala.