☕ Um Café no Bellacosa Mainframe
Gostou do conteúdo? Ajude a manter o café quente, o COBOL compilando e o mainframe acordado. 😄
☕ Pague um café ao Bellacosa

Translate

Mostrar mensagens com a etiqueta SRE. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta SRE. Mostrar todas as mensagens

quarta-feira, 2 de setembro de 2020

🧝‍♀️ GALADRIEL E O ESPELHO DE PROMETHEUS

 

Bellacosa Mainframe apresenta o Prometheus

☕ Um Café no Bellacosa Mainframe

🧝‍♀️ GALADRIEL E O ESPELHO DE PROMETHEUS

Métricas, exporters, targets, PromQL, Grafana, Alertmanager, observabilidade e a antiga arte de descobrir que a produção estava morrendo antes que o telefone tocasse.

Há sistemas que anunciam sua queda com trombetas.

Há outros que simplesmente morrem.

E existem os mais perigosos: aqueles que continuam aparentemente vivos enquanto, lentamente, alguma coisa começa a apodrecer por dentro.

Uma fila cresce. A latência aumenta. Uma aplicação começa a devolver mais erros. Um processo batch demora alguns minutos a mais todos os dias. A CPU parece normal. O CICS continua respondendo. O Db2 está UP. Nenhum job terminou com CC 0012.

Ainda assim, alguma coisa está errada.

Se estivéssemos em Lothlórien, talvez Galadriel nos conduzisse até seu espelho e dissesse:

“O espelho mostra muitas coisas. Coisas que foram, coisas que são e algumas coisas que ainda podem acontecer.”

No nosso reino, entretanto, não temos o Espelho de Galadriel.

Temos Prometheus.

E talvez isso seja até melhor, porque Prometheus não trabalha com profecias.

Ele trabalha com métricas.



🎬 PRÓLOGO — GALADRIEL OLHA PARA PRODUÇÃO

Imagine que você seja um programador COBOL iniciante.

Você escreveu seu programa, compilou, link-editou, submeteu o JCL e recebeu:

IEF142I JOB001 STEP01 - STEP WAS EXECUTED - COND CODE 0000

Maravilha!

Funcionou.

Só existe um pequeno problema.

Isso não significa que o sistema esteja saudável.

Um programa pode terminar com CC 0000 e consumir recursos demais.

Uma transação pode funcionar e levar quatro segundos.

Um serviço pode estar disponível enquanto 8% das requisições estão falhando.

Uma fila MQ pode estar funcionando perfeitamente enquanto cresce mais rapidamente do que os consumidores conseguem processá-la.

Uma aplicação pode estar tecnicamente UP e praticamente inutilizável.

É nesse momento que precisamos distinguir duas ideias:

FUNCIONAR

e

ESTAR SAUDÁVEL

São coisas diferentes.

Prometheus existe justamente para nos ajudar a observar essa segunda dimensão.



🧝 CAPÍTULO 1 — “VOCÊ NÃO PODE CORRIGIR AQUILO QUE NÃO CONSEGUE VER”

Antes de estudar Prometheus, precisamos falar de observabilidade.

Monitoramento tradicional normalmente pergunta:

CPU está alta?

Memória acabou?

Servidor está UP?

Banco está disponível?

Fila está cheia?

São perguntas importantes.

Observabilidade tenta responder perguntas maiores:

O que aconteceu?

Quando começou?

Onde aconteceu?

Quem foi afetado?

Por que aconteceu?

Está piorando?

Qual componente provavelmente participa do problema?

Uma forma didática muito usada para apresentar observabilidade fala em três grandes sinais:

METRICS
LOGS
TRACES

Podemos pensar assim:

Metrics mostram numericamente o comportamento do sistema.

Logs registram acontecimentos e detalhes.

Traces acompanham o caminho de uma operação através de vários componentes.

Imagine uma transação:

Cliente
   ↓
API
   ↓
MQ
   ↓
CICS
   ↓
COBOL
   ↓
Db2

Uma métrica pode dizer:

latência p95 = 2,4 segundos

O log pode mostrar:

SQLCODE -911

E um trace pode revelar que a maior parte daqueles 2,4 segundos aconteceu no acesso ao banco.

Agora começamos a enxergar o sistema.



💍 CAPÍTULO 2 — OS QUATRO SINAIS DOURADOS

Na literatura de SRE aparece frequentemente a ideia dos Four Golden Signals:

Latency
Traffic
Errors
Saturation

Para quem vem de mainframe, os nomes podem ser modernos, mas o raciocínio é muito familiar.

Latency

Quanto tempo algo demora?

CICS transaction response time
API response time
SQL elapsed time
batch elapsed time

Traffic

Quanto trabalho estamos recebendo?

transactions/sec
requests/sec
messages/sec
jobs/hour

Errors

Quanto está falhando?

HTTP 500
ABENDs
SQL errors
MQ failures
rejected transactions

Saturation

Quanto estamos nos aproximando do limite?

CPU
memory
connections
threads
queue depth
storage

Aqui existe uma lição importante.

CPU alta não significa automaticamente problema.

Imagine:

CPU      = 91%
Latency  = normal
Errors   = normal
Traffic  = altíssimo

Talvez a máquina simplesmente esteja trabalhando bastante.

Agora imagine:

CPU      = 42%
Latency  = 8 segundos
Errors   = crescendo
Traffic  = normal

Temos provavelmente algo muito mais preocupante.

O número isolado raramente conta a história inteira.



🔥 CAPÍTULO 3 — AFINAL, O QUE É PROMETHEUS?

Prometheus é um sistema open source para monitoramento e alertas baseado principalmente em métricas de séries temporais.

Podemos resumir sua missão assim:

COLETAR
   ↓
ARMAZENAR
   ↓
CONSULTAR
   ↓
AVALIAR
   ↓
ALERTAR

A palavra importante aqui é:

tempo.

Imagine simplesmente:

CPU = 84%

Esse número tem pouca informação.

Agora:

10:00  CPU 31%
10:01  CPU 38%
10:02  CPU 47%
10:03  CPU 63%
10:04  CPU 84%
10:05  CPU 96%

A situação mudou completamente.

Não temos apenas um valor.

Temos uma história.

E Prometheus é, em grande parte, uma máquina especializada em guardar e consultar essas histórias numéricas.



🕰️ CAPÍTULO 4 — TIME SERIES: O TEMPO CONTA A HISTÓRIA

Considere:

mq_queue_depth = 1400

Ruim?

Depende.

Talvez aquela fila normalmente tenha 5.000 mensagens.

Agora veja:

03:13   17
03:14   22
03:15   51
03:16   194
03:17   830
03:18   1.402
03:19   2.917

Agora temos uma história bastante diferente.

Às 03:17, alguma coisa aconteceu.

Sim, jovem padawan do COBOL: você encontrou o pequeno easter egg escondido no SYSOUT. ☕

Talvez o produtor tenha aumentado o ritmo.

Talvez um consumidor tenha parado.

Talvez alguma dependência esteja lenta.

Prometheus não sabe necessariamente a causa.

Mas agora temos uma pista extremamente importante:

QUANDO?

Esse é um dos maiores valores das séries temporais.


🏷️ CAPÍTULO 5 — LABELS: OS NOMES SECRETOS DAS COISAS

Suponha que tenhamos:

cics_transactions_total

Interessante.

Mas podemos enriquecer:

cics_transactions_total{
    region="CICSPROD",
    transaction="PAY1",
    status="success"
}

Os valores entre {} são labels.

Agora podemos perguntar:

transações por região
transações por status
transações por aplicação
transações por ambiente

Isso é poderosíssimo.

Porém Galadriel provavelmente levantaria uma sobrancelha e diria:

“Nem todas as labels deveriam ter sido criadas.”

Porque existe um monstro chamado:

💣 CARDINALIDADE

Imagine:

payment_total{
    channel="mobile",
    status="approved"
}

Perfeito.

Existem poucos canais e poucos status.

Agora alguém tem a brilhante ideia:

payment_total{
    customer_id="123456789",
    transaction_id="982737283928382"
}

Catástrofe em potencial.

Cada combinação diferente de labels pode criar outra série temporal.

Milhões de clientes multiplicados por milhões de transações podem gerar uma quantidade gigantesca de séries.

Portanto:

Label não é campo de banco de dados.

Não coloque tudo nela.

Esse é um dos conhecimentos que separa quem simplesmente instalou Prometheus de quem começou realmente a entendê-lo.




🧙 CAPÍTULO 6 — EXPORTERS: OS INTÉRPRETES ENTRE OS REINOS

Nem todo sistema nasceu sabendo falar Prometheus.

É aí que entram os exporters.

Um exporter obtém informações de determinado sistema e as apresenta de uma maneira que Prometheus consegue coletar.

Exemplo:

Linux
   ↓
Node Exporter
   ↓
/metrics
   ↑
Prometheus

Temos exporters para diferentes tecnologias e também podemos desenvolver exporters específicos.

Essa arquitetura é particularmente interessante para legado.

Imagine:

IBM Z
 ├── CICS
 ├── Db2
 ├── MQ
 ├── JES2
 └── z/OS
       ↓
  coleta/adaptação
       ↓
 Custom Exporter
       ↓
    /metrics
       ↑
   Prometheus

Pense no exporter como um tradutor.

O sistema pode continuar falando sua língua ancestral.

O exporter traduz os dados relevantes para o idioma esperado pelo ecossistema Prometheus.


🎯 CAPÍTULO 7 — EXPORTER NÃO É TARGET

Aqui aparece uma confusão comum.

Exporter é o software/adaptador que expõe métricas.

Target é o endpoint que Prometheus vai coletar.

Por exemplo:

server01:9100
server02:9100
server03:9100

podem ser targets.

E normalmente Prometheus encontrará ali:

/metrics

Portanto:

TARGET
   ↓
endpoint monitorado

EXPORTER
   ↓
componente que expõe métricas

Uma aplicação também pode implementar /metrics diretamente.

Nesse caso:

Application
     ↓
  /metrics
     ↑
Prometheus

Não precisamos necessariamente colocar outro exporter entre eles.


🧲 CAPÍTULO 8 — PROMETHEUS PUXA AS MÉTRICAS

Uma característica famosa do Prometheus é seu modelo predominantemente pull.

Em termos simplificados:

Prometheus
    |
    | HTTP GET
    ↓
http://server:9100/metrics

Ele pergunta:

“Quais são seus números agora?”

O target responde.

Depois Prometheus volta novamente.

E novamente.

Isso é chamado de scraping.

Imagine:

15 segundos
      ↓
scrape

15 segundos
      ↓
scrape

15 segundos
      ↓
scrape

O intervalo depende da configuração.

Existe suporte para cenários de push, particularmente através do Pushgateway para determinados workloads de curta duração, mas compreender o modelo pull primeiro ajuda muito.


📜 CAPÍTULO 9 — prometheus.yml: O JCL DO REINO

Agora chegamos a uma parte que fará qualquer mainframer sorrir.

Prometheus precisa saber:

o que coletar
onde coletar
com qual frequência
como organizar

Grande parte disso aparece no:

prometheus.yml

Exemplo simplificado:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: "linux"
    static_configs:
      - targets:
          - "server01:9100"
          - "server02:9100"

Um mainframer olha para isso e imediatamente pensa:

“Então esse YAML está dizendo ao Prometheus qual trabalho executar.”

Exatamente.

Não é literalmente JCL, mas conceitualmente a analogia ajuda:

JCL
↓
descreve execução

prometheus.yml
↓
descreve comportamento de coleta/configuração

Cuidado apenas para não levar a analogia longe demais.


🧭 CAPÍTULO 10 — SERVICE DISCOVERY

Targets fixos funcionam bem quando temos:

server01
server02
server03

Mas imagine Kubernetes.

Agora:

10 pods

Cinco minutos depois:

27 pods

Mais tarde:

8 pods

Seria absurdo alguém editar manualmente prometheus.yml a cada mudança.

Entra então Service Discovery.

Prometheus pode descobrir dinamicamente os targets através de mecanismos de descoberta.

Conceitualmente:

Kubernetes
     ↓
Service Discovery
     ↓
Prometheus descobre targets
     ↓
scraping

Esse conceito é fundamental em cloud-native porque a infraestrutura deixou de ser necessariamente estática.

O servidor deixou de ser um castelo.

Passou a ser quase uma barraca de campanha: aparece, trabalha e desaparece.


📦 CAPÍTULO 11 — COUNTER: O CONTADOR QUE SÓ SABE AVANÇAR

Primeiro tipo fundamental de métrica:

Counter.

Exemplo:

http_requests_total

Ele cresce:

100
101
105
120
180

Normalmente só volta para baixo quando o processo reinicia.

Excelente para:

requests
transactions
errors
jobs completed
messages processed

Mas existe uma armadilha.

Perguntar:

http_requests_total = 938.281.293

não é muito útil.

Você quer saber:

“Quão rapidamente isso está crescendo?”

E então aparece PromQL.


🌊 CAPÍTULO 12 — rate(): A VELOCIDADE DO RIO

Imagine:

rate(http_requests_total[5m])

Estamos aproximadamente perguntando pela taxa média de crescimento por segundo naquele intervalo.

Se:

resultado = 150

podemos interpretar, dentro daquele contexto, algo como:

150 requests/s

Para CICS poderíamos imaginar:

rate(cics_transactions_total[5m])

Agora temos algo semelhante a TPS.

Essa é uma transformação importantíssima:

COUNTER
↓
rate()
↓
VELOCIDADE

📈 CAPÍTULO 13 — increase(): QUANTO CRESCEU?

Outra função extremamente útil:

increase(http_requests_total[1h])

Pergunta conceitualmente:

Quanto esse counter aumentou durante uma hora?

Compare:

rate()
→ ritmo

increase()
→ aumento no período

Uma analogia simples:

velocímetro → rate()

odômetro percorrido na viagem → increase()

🌡️ CAPÍTULO 14 — GAUGE: O TERMÔMETRO

Gauge pode aumentar e diminuir.

Exemplos:

CPU
memory
temperature
active connections
queue depth
active tasks

Imagine MQ:

mq_queue_depth

Valores:

08:00   14
08:01   17
08:02   25
08:03   81
08:04   320
08:05   982

Isso não prova sozinho qual é o problema.

Mas é um indício espetacular.

O produtor pode estar produzindo mais rapidamente.

O consumidor pode ter ficado lento.

O consumidor pode ter parado.

Alguma dependência pode estar congestionada.

A métrica é a pista.

A investigação continua.


📊 CAPÍTULO 15 — HISTOGRAM: A MÉDIA PODE MENTIR

Imagine tempos de resposta:

20 ms
22 ms
23 ms
25 ms
26 ms
29 ms
32 ms
4.000 ms

Calcular somente a média pode esconder uma experiência terrível para uma parcela dos usuários.

Por isso observabilidade fala tanto em:

p50
p90
p95
p99

Se dissermos:

p95 = 800 ms

estamos falando aproximadamente do valor abaixo do qual ficaram 95% das observações.

Histograms organizam observações em buckets e permitem estudar a distribuição.

Isso é extremamente útil para:

latência
tamanho de payload
tempo de processamento

🧮 CAPÍTULO 16 — SUMMARY: PARECIDO, MAS NÃO IGUAL

Summary também trabalha com distribuições e quantis.

A diferença arquitetural importante é que summaries tradicionalmente calculam quantis no cliente, enquanto histograms expõem dados que permitem ao Prometheus trabalhar posteriormente com a distribuição.

Isso tem consequência em ambientes distribuídos.

Imagine:

100 instâncias

Queremos calcular:

p95 global

Histograms normalmente são muito mais apropriados para agregação entre várias instâncias.

Não escolha Summary simplesmente porque o nome parece mais simpático.


🔮 CAPÍTULO 17 — PROMQL: A LÍNGUA DO ESPELHO

Agora chegamos ao coração intelectual da coisa.

PromQL é a linguagem de consulta do Prometheus.

Ela permite selecionar, filtrar, combinar e agregar séries temporais.

Por exemplo:

rate(http_requests_total[5m])

Ou:

sum by(service)(
  rate(http_requests_total[5m])
)

Agora perguntamos:

Quantas requisições por segundo cada serviço está processando?

Podemos filtrar labels:

http_requests_total{environment="prod"}

Ou:

http_requests_total{
    environment="prod",
    status="500"
}

Aqui Prometheus deixa de ser simplesmente coletor.

Ele vira ferramenta investigativa.


⚠️ CAPÍTULO 18 — PROMQL CORRETA PODE RESPONDER A PERGUNTA ERRADA

Essa é uma das melhores lições escondidas nas imagens.

Imagine alguém escrevendo:

avg(http_request_duration_seconds)

e dizendo:

“Essa é a latência média.”

Calma.

Primeiro precisamos entender que métrica é essa.

Gauge?

Histogram?

Summary?

Qual dimensão?

Qual intervalo?

O mesmo problema aparece em exemplos de CPU.

Algo como:

rate(node_cpu_seconds_total[5m]) > 80

não significa automaticamente:

CPU > 80%

node_cpu_seconds_total representa segundos acumulados de CPU separados por modos.

Uma consulta mais típica para utilização pode partir da proporção de idle:

100 *
(
  1 -
  avg by(instance)(
    rate(node_cpu_seconds_total{mode="idle"}[5m])
  )
)

A lição vale ouro:

Query que executa sem erro não é necessariamente query correta.

COBOLers conhecem muito bem esse fenômeno.

Um programa pode terminar:

CC 0000

e ainda assim produzir o resultado errado.

PromQL não é diferente.


🧠 CAPÍTULO 19 — RECORDING RULES: AS MATERIALIZED VIEWS DO PROMETHEUS

Imagine uma consulta PromQL pesada utilizada por vinte dashboards.

Executá-la constantemente pode ser caro.

Podemos criar uma Recording Rule.

Conceitualmente:

RAW METRICS
     ↓
PROMQL COMPLEXA
     ↓
RECORDING RULE
     ↓
NOVA TIME SERIES

Isso lembra bastante uma:

MATERIALIZED VIEW

de banco de dados.

Você calcula antecipadamente algo que será consultado frequentemente.

Resultado:

dashboards mais rápidos
queries mais simples
menor trabalho repetitivo

🚨 CAPÍTULO 20 — ALERTING RULES: QUANDO O ESPELHO GRITA

Agora queremos transformar observação em ação.

Uma Alerting Rule pode expressar:

SE condição acontecer
E persistir
ENTÃO gere alerta

Exemplo conceitual:

alert: HighLatency

expr: alguma_expressao > limite

for: 5m

labels:
  severity: warning

O for: é importantíssimo.

Imagine CPU:

14:00:01  92%
14:00:10  48%

Queremos chamar alguém?

Provavelmente não.

Foi apenas um pico.

Agora:

14:00  92%
14:01  94%
14:02  96%
14:03  95%
14:04  97%
14:05  96%

A história mudou.

Por isso os estados de um alerta podem passar conceitualmente por:

Inactive
   ↓
Pending
   ↓
Firing

🔔 CAPÍTULO 21 — PROMETHEUS DETECTA; ALERTMANAGER ORGANIZA A GUERRA

Prometheus e Alertmanager têm responsabilidades diferentes.

Prometheus determina:

"A condição do alerta aconteceu."

Alertmanager pergunta:

"Quem precisa saber?"

Ele pode:

agrupar
rotear
silenciar
inibir
encaminhar

Imagine cinquenta servidores falhando porque um único switch morreu.

Você provavelmente não quer:

50 × email
50 × Slack
50 × pager

Você quer contexto e agrupamento.

Esse é o trabalho do Alertmanager.


📺 CAPÍTULO 22 — GRAFANA NÃO É PROMETHEUS

Outra confusão comum:

Grafana ≠ Prometheus

Prometheus fornece os dados e responde às consultas.

Grafana os transforma em visualizações.

Prometheus
     ↑
   PromQL
     │
  Grafana

Grafana pode produzir:

gráficos
tabelas
gauges
heatmaps
dashboards

Mas existe uma armadilha sedutora.

Criar um dashboard com 93 gráficos e pensar:

“Nossa observabilidade está fantástica!”

Talvez não esteja.

Dashboard bom responde perguntas:

Estamos saudáveis?

Usuários estão sendo afetados?

Quando começou?

Onde está acontecendo?

Está piorando?

O que devo investigar?

Se o painel não ajuda nisso, temos apenas uma televisão extremamente sofisticada mostrando números coloridos.


🏦 CAPÍTULO 23 — PROMETHEUS ENTRA NO PROCESSAMENTO DE CARTÕES

Imagine:

AUTHORIZATION
      ↓
CAPTURE
      ↓
CLEARING
      ↓
SETTLEMENT

Instrumentamos:

card_authorizations_total

card_authorization_errors_total

card_authorization_duration_seconds

clearing_transactions_total

settlement_failures_total

Agora podemos observar:

TPS
error rate
latency
rejection rate
backlog

Perceba o salto.

Começamos monitorando:

CPU
memory
disk

Agora estamos monitorando:

O NEGÓCIO.

Isso é muito mais interessante.


🦖 CAPÍTULO 24 — PROMETHEUS ENCONTRA O MAINFRAME

Imagine um dashboard:

╔════════════════════════════════════╗
║          CICS PRODUCTION           ║
╠════════════════════════════════════╣
║ TPS                    2.841       ║
║ p95                    184 ms      ║
║ ABEND Rate             0,02%       ║
║ Active Tasks           117         ║
║ MQ Queue Depth          14         ║
║ CPU                     63%        ║
╚════════════════════════════════════╝

De repente o operador percebe:

03:15   MQ depth 17
03:16   MQ depth 34
03:17   MQ depth 581
03:18   MQ depth 1.307

Consulta outra métrica.

TPS continua normal.

Outra.

CICS response time começou a aumentar às 03:16:48.

Outra.

Db2 latency aumentou às 03:16:31.

Agora temos uma linha investigativa:

Db2 latency
      ↓
CICS latency
      ↓
MQ backlog
      ↓
experiência do usuário

É quase arqueologia de incidente em tempo real.


🕵️ CAPÍTULO 25 — NÃO ALERTE SOBRE RUÍDO

Existe uma regra de ouro operacional:

Alertar sobre tudo
=
não alertar sobre nada

Porque seres humanos aprendem rapidamente a ignorar alarmes inúteis.

Imagine receber diariamente:

CPU 81%
CPU 82%
CPU 84%
CPU 81%
CPU 83%

Depois de algumas semanas:

"Ah, é aquele alerta."

Até chegar o dia em que:

CPU 99%
latency 12s
errors 31%

E alguém automaticamente pensa:

“É aquele alerta.”

Isso é alert fatigue.

Por isso, quando possível, é melhor aproximar alertas de sintomas relevantes:

error rate
latency
availability
SLO violation
queue growth

em vez de transformar todo pico técnico em emergência.


📚 CAPÍTULO 26 — PROMETHEUS NÃO É SEU LEDGER

Outra distinção fundamental.

Imagine que Prometheus indique:

1.984.322 pagamentos

Podemos usar isso para observar comportamento.

Mas se a pergunta for:

“Quantos pagamentos exatamente precisam ser liquidados?”

Procure a fonte transacional oficial.

database
transaction log
ledger
audit trail

Prometheus é sistema de observabilidade.

Não deveria ser tratado como livro contábil de transações.

Para um mainframer isso é especialmente fácil de compreender:

SMF ≠ arquivo mestre do cliente

RMF ≠ ledger financeiro

Prometheus ≠ sistema de registro transacional

Cada coisa tem sua finalidade.


🛠️ CAPÍTULO 27 — LABORATÓRIO DO APRENDIZ

Se eu estivesse ensinando Prometheus para um COBOLer iniciante, faria o aprendizado nesta ordem:

Primeiro, subiria Prometheus localmente.

Depois, instalaria Node Exporter.

Então observaria:

http://localhost:9100/metrics

Sem Grafana.

Isso é importante.

Veja primeiro a matéria-prima.

Procure métricas.

Entenda nomes e labels.

Depois vá à interface do Prometheus e experimente:

up

Depois:

node_cpu_seconds_total

Depois:

rate(node_cpu_seconds_total[5m])

Só depois começaria:

sum()
avg()
max()
topk()
histogram_quantile()

Então Grafana.

Depois alertas.

Depois Alertmanager.

Finalmente:

service discovery
recording rules
remote storage
HA
federation
OpenTelemetry

A ordem importa.

Quem começa instalando um dashboard pronto pode acabar sabendo operar o painel sem compreender o sistema.

É como aprender ISPF decorando PF keys sem compreender datasets, jobs e address spaces.


💡 CAPÍTULO 28 — CURIOSIDADES QUE VALEM UM CAFÉ

Prometheus nasceu no SoundCloud e posteriormente tornou-se projeto da CNCF.

O nome vem do Prometeu da mitologia grega, associado ao roubo do fogo dos deuses para entregá-lo aos humanos.

É uma escolha curiosamente apropriada.

O Prometheus moderno também nos entrega “fogo”:

dados
visibilidade
conhecimento

Grafana, por sua vez, não faz parte do Prometheus propriamente dito. Eles trabalham maravilhosamente juntos, mas são projetos separados.

Outra curiosidade importante: Prometheus consegue monitorar a si próprio.

Sim.

O vigia também pode ser vigiado.

E isso é essencial.

Porque existe algo pior do que um sistema cair:

o sistema cair enquanto seu monitoramento também está quebrado e ninguém perceber.


🧝‍♀️ EPÍLOGO — O ESPELHO NÃO PREVÊ O FUTURO

Galadriel observa novamente a superfície do espelho.

Mas dessa vez não aparecem exércitos de Mordor.

Aparecem gráficos.

Latency       ↗
Errors        ↗
Traffic       →
Saturation    ↗

Um aprendiz pergunta:

— Senhora, isso significa que o sistema cairá?

Galadriel responde:

— Não.

Porque métricas não são profecias.

Elas são evidências.

Prometheus não nos diz necessariamente o futuro.

Ele nos permite perceber que o presente está mudando.

E essa talvez seja a ideia mais importante de toda esta história.

O objetivo final não é:

INSTALAR PROMETHEUS

Nem:

CRIAR GRAFANA

Nem:

TER 500 MÉTRICAS

Muito menos:

CRIAR 200 ALERTAS

O objetivo é construir um sistema no qual, quando alguém disser:

“Produção está estranha.”

possamos responder:

Quando começou?

O que mudou?

Quem foi afetado?

Qual serviço degradou?

Qual é a tendência?

Qual foi a sequência dos acontecimentos?

E começar a encontrar respostas.


☕ O HOLOCRON DO PROGRAMADOR COBOL

Se você guardar apenas uma página deste enorme pergaminho de Lothlórien, guarde esta:

                OBSERVABILIDADE
                      │
          ┌───────────┼───────────┐
          │           │           │
       METRICS       LOGS       TRACES
          │
          ▼
       TARGETS
          │
     /metrics
          │
          ▼
      PROMETHEUS
          │
   ┌──────┼───────────────┐
   │      │               │
  TSDB   PromQL          RULES
   │      │               │
   │      │        ┌──────┴──────┐
   │      │        │             │
   │      │   Recording       Alerting
   │      │                      │
   │      │                      ▼
   │      │                Alertmanager
   │      │
   └──────┴──────────────► Grafana

E abaixo dele escreva:

Counter
→ algo acumulativo

Gauge
→ estado que sobe e desce

Histogram
→ distribuição em buckets

Summary
→ distribuição/quantis calculados no cliente

rate()
→ velocidade de crescimento

increase()
→ crescimento durante um intervalo

Labels
→ dimensões das séries

High Cardinality
→ perigo

Recording Rules
→ pré-calcular

Alerting Rules
→ detectar condições

Alertmanager
→ administrar notificações

Grafana
→ visualizar

PromQL
→ interrogar as séries

E finalmente uma última inscrição, talvez gravada na porta da sala de operações:

“CC 0000 apenas diz que o programa terminou. Observabilidade tenta descobrir se o reino continua saudável.”

Porque, no fim, Prometheus não é sobre CPU, dashboards ou gráficos.

É sobre transformar comportamento em métricas, métricas em séries temporais, séries em perguntas, perguntas em evidências e evidências em ação.

O velho programador COBOL pode olhar para exporters, YAML, PromQL, Grafana, Kubernetes e inicialmente pensar que chegou à Terra-média.

Mas, depois de remover os nomes modernos, encontrará conceitos bastante familiares:

medir
registrar
comparar
correlacionar
detectar
investigar
agir

Mudaram as ferramentas.

Mudaram os nomes.

Mudaram os castelos.

A missão permanece praticamente a mesma.

Descobrir o que está acontecendo dentro da máquina antes que aquilo que acontece dentro da máquina comece a acontecer com os usuários.

E se às 03:17 uma pequena fila começar silenciosamente a crescer...

...talvez o Espelho de Prometheus já esteja mostrando alguma coisa. 🔥🧝‍♀️☕

segunda-feira, 1 de outubro de 2018

🚨 INCEPTION, CLAYMORE E A DUNGEON DO SEV-1 — QUANDO O PROGRAMADOR COBOL DESCOBRIU QUE REINICIAR PRODUÇÃO NÃO ERA ANÁLISE DE CAUSA RAIZ

 

Bellacosa Mainframe apresenta o SEV-1

☕ UM CAFÉ NO BELLACOSA MAINFRAME

🚨 INCEPTION, CLAYMORE E A DUNGEON DO SEV-1 — QUANDO O PROGRAMADOR COBOL DESCOBRIU QUE REINICIAR PRODUÇÃO NÃO ERA ANÁLISE DE CAUSA RAIZ

Incident Response, SEV-1, Blast Radius, Observabilidade, SRE, Incident Commander, Evidence-Driven Investigation, CICS, Db2, MQ, SDSF, SMF, RMF, WLM, retries, circuit breakers — e o dia em que descobrimos que o monstro talvez estivesse três camadas abaixo da realidade.



🎬 PRÓLOGO — O TELEFONE TOCOU ÀS 03:17

03:17.

Existe um horário particularmente adequado para sistemas de produção quebrarem.

Nunca às 14:30 de uma terça-feira tranquila, quando todos estão no escritório, o café está fresco e o especialista em Db2 acabou de voltar do almoço.

Não.

Produção prefere horários dramáticos.

03:17.

Nosso jovem programador COBOL acordou com o telefone vibrando.

Na tela havia apenas uma mensagem:

PRODUÇÃO FORA. SEV-1. ENTRA NA BRIDGE.

Ele abriu o notebook ainda tentando lembrar se estava acordado.

TSO.

ISPF.

SDSF.

Ao entrar na conferência encontrou uma pequena multidão.

— Deve ser Db2.

— Reinicia CICS.

— Foi o deploy.

— Não mexemos em nada.

— A CPU está normal.

— MQ está com fila.

— A rede está estranha.

— Do meu lado está tudo verde.

E então surgiu a primeira professora.

Clare, de Claymore, apoiou a espada imaginária sobre a mesa.

— Você está olhando para o monstro errado.

Antes que nosso programador pudesse perguntar qualquer coisa, outra voz surgiu.

Desta vez era Cobb, de Inception.

— E você está olhando apenas para a primeira camada.

Bem-vindo ao mundo de Incident Response.

Hoje não aprenderemos apenas como encontrar um erro.

Aprenderemos algo muito mais importante:

como pensar quando ninguém ainda sabe onde está o erro.



🧯 CAPÍTULO 1 — INCIDENTE NÃO É SINÔNIMO DE ERRO

Para começar do começo, precisamos separar três conceitos:

ALERT
INCIDENT
PROBLEM

Eles parecem semelhantes.

Não são.

Imagine que um job COBOL terminou:

JOB PAYROLL1
STEP010

ABEND S0C7

Temos um erro.

Talvez exista um alerta.

Mas isso necessariamente representa um grande incidente?

Não.

Talvez fosse um job de teste.

Talvez houvesse recuperação automática.

Talvez nenhum usuário tenha sido afetado.

Agora imagine outra situação.

Nenhum programa abendou.

CICS está UP.

Db2 está UP.

MQ está UP.

CPU está em 45%.

Tudo parece lindo.

Entretanto, uma transação que normalmente responde em 300 milissegundos agora leva 18 segundos.

Os clientes começaram a abandonar operações.

Temos um incidente.

Alert

Um alerta é um sinal:

alguma coisa talvez esteja errada.

Exemplo:

CPU > 80% por 5 minutos

Incident

Um incidente existe quando há impacto real ou iminente sobre serviço, usuários ou negócio.

Problem

O problema é a causa subjacente associada ao incidente — usando aqui a terminologia tradicional de gestão de serviços.

Podemos ter:

MEMORY LEAK
     ↓
   PROBLEM
     ↓
aplicação degrada
     ↓
  INCIDENT
     ↓
CPU/memória dispara
     ↓
   ALERT

Percebeu a inversão?

O alerta que você viu pode ser o último elo de uma cadeia que começou muito antes.

Primeira lição de Clare:

O primeiro monstro que você encontra não necessariamente é o monstro que iniciou a batalha.



🔥 CAPÍTULO 2 — PRIMEIRO SALVE A ALDEIA, DEPOIS AUTOPSIE O YOUma

Programadores possuem uma tendência compreensível.

Quando alguma coisa quebra:

descobrir erro
     ↓
corrigir erro
     ↓
voltar produção

Incident Response acrescenta outra prioridade.

detectar
   ↓
conter
   ↓
mitigar
   ↓
restaurar
   ↓
estabilizar
   ↓
investigar profundamente

Essa diferença é gigantesca.

Suponha que às 10:00 entrou a versão 2.3 de uma aplicação.

Às 10:07 começaram erros.

A versão 2.2 era estável.

Talvez descobrir o bug exato demore três horas.

Mas voltar para 2.2 pode demorar dez minutos.

Nesse cenário, pode fazer sentido operacionalmente:

V2.3
 ↓
ROLLBACK
 ↓
V2.2
 ↓
SERVIÇO RESTAURADO

e depois investigar V2.3.

Isso é mitigation.

Não necessariamente root-cause resolution.

É aqui que Cobb desenha dois círculos no quadro.

RESTORE SERVICE ≠ FIND ROOT CAUSE

E diz:

— São camadas diferentes do sonho.

Você pode restaurar o serviço sem conhecer ainda a causa definitiva.

E pode descobrir a causa sem ter restaurado o serviço.

Em um SEV-1, reduzir o dano ao cliente normalmente possui prioridade imediata.



⏱️ CAPÍTULO 3 — OS PRIMEIROS 15 MINUTOS

Existe uma disciplina específica para os primeiros minutos.

Um fluxo útil é:

1. Confirmar o incidente
2. Determinar impacto
3. Determinar blast radius
4. Verificar mudanças recentes
5. Definir responsáveis
6. Criar canais de comunicação
7. Preservar evidências
8. Suspender mudanças perigosas
9. Criar hipóteses
10. Decidir mitigação

Observe algo curioso.

Não existe:

3. REINICIE TUDO

Isso merece ser colocado numa caneca.

Antes de alterar o estado, observe.

Imagine que uma região CICS apresenta comportamento estranho.

Alguém imediatamente ordena:

CEMT PERFORM SHUTDOWN

Ela volta.

Problema resolvido?

Talvez.

Mas o restart pode ter eliminado justamente aquilo que permitiria descobrir a causa:

  • tasks;
  • locks;
  • storage;
  • conexões;
  • estados intermediários;
  • dumps;
  • filas transitórias;
  • threads;
  • informações temporais.

É o equivalente digital de chegar à cena de um crime e decidir:

Vamos limpar tudo antes da perícia.

Clare provavelmente desembainharia a espada nesse momento.


🔎

CAPÍTULO 4 — NÃO MUDE A CENA DO CRIME

Um dos princípios mais importantes de Incident Response é:

OBSERVE BEFORE CHANGING STATE

Antes de restart, rollback, cancelamento ou alteração:

  1. colete métricas;
  2. salve logs;
  3. registre horários;
  4. identifique processos;
  5. registre mensagens;
  6. preserve dumps quando necessários;
  7. documente configurações;
  8. determine quem está afetado.

No mainframe poderíamos consultar, conforme o problema:

SDSF
SYSLOG
JES spool
SMF
RMF
CICS statistics
Db2 statistics
MQ statistics
system dumps
application logs

Isso não significa nunca reiniciar.

Significa:

saiba por que está reiniciando e registre o estado antes, quando for possível e seguro.


🧠 CAPÍTULO 5 — INCEPTION: DESÇA UMA CAMADA

Agora Cobb assume a aula.

Um usuário diz:

O sistema está fora.

Isso é o nível zero.

Mas qual sistema?

Vamos entrar no sonho.

USUÁRIO
   ↓
DNS
   ↓
LOAD BALANCER
   ↓
PROXY/API GATEWAY
   ↓
APLICAÇÃO
   ↓
CICS
   ↓
COBOL
   ↓
DB2
   ↓
MQ
   ↓
OUTRO SISTEMA

O COBOL pode estar perfeito.

Talvez o usuário nem esteja conseguindo chegar até ele.

Um certificado TLS expirado pode fazer parecer que a aplicação caiu.

DNS pode falhar.

Um firewall pode bloquear tráfego.

O load balancer pode considerar determinado backend unhealthy.

Uma API externa pode estar lenta.

O Db2 pode estar esperando locks.

MQ pode estar acumulando mensagens.

É o princípio de Request Path Reconstruction.

Para cada hop, perguntamos:

A requisição chegou?

Saiu?

Quanto tempo permaneceu?

Qual código retornou?

É extraordinariamente poderoso.


🎯 CAPÍTULO 6 — BLAST RADIUS: QUAL O TAMANHO DO MONSTRO?

Clare conhece bem essa pergunta.

Você vê um Yoma.

Mas existem quantos?

Em Incident Response chamamos isso de blast radius.

Literalmente:

raio da explosão.

Perguntas fundamentais:

Todos os clientes?

Alguns clientes?

Todos os países?

Uma região?

Uma LPAR?

Um sysplex?

Uma aplicação?

Uma região CICS?

Uma transação?

Um endpoint?

Uma versão?

Imagine:

São Paulo     ERRO
Rio           OK
Curitiba      OK

Essa única informação vale ouro.

Se duas regiões equivalentes funcionam e apenas uma falha, várias hipóteses globais perdem força.


🪞 CAPÍTULO 7 — O SISTEMA SAUDÁVEL É SEU MELHOR DETETIVE

Existe uma técnica extremamente simples:

healthy versus unhealthy.

Compare aquilo que funciona com aquilo que não funciona.

LPAR A                 LPAR B
------                 ------
ERRO                    OK

CICS A                  CICS B
Db2 A                   Db2 B
MQ A                    MQ B

Agora pergunte:

O que é diferente?

Compare:

  • configuração;
  • versão;
  • PTF;
  • load module;
  • package Db2;
  • WLM;
  • RACF;
  • datasets;
  • conexões;
  • rede;
  • volume;
  • horário;
  • dependências.

Essa pergunta costuma ser melhor do que:

O que está errado?

Porque você ganhou um controle experimental.


🧪 CAPÍTULO 8 — INCIDENT RESPONSE É MÉTODO CIENTÍFICO

Chegamos a uma das partes mais fascinantes.

Uma investigação madura segue aproximadamente:

SINTOMA
 ↓
ESCOPO
 ↓
TIMELINE
 ↓
MUDANÇAS
 ↓
EVIDÊNCIAS
 ↓
HIPÓTESES
 ↓
TESTES
 ↓
ELIMINAÇÃO
 ↓
ROOT CAUSE

Suponha:

CICS está demorando oito segundos.

Hipótese:

Db2 está lento.

Então medimos.

CICS elapsed       8.200 ms
Db2                 43 ms
MQ                   18 ms
External API       7.800 ms

Ops.

Db2 não parece mais nosso principal suspeito.

A investigação não procurou somente confirmar a hipótese.

Procurou evidência capaz de destruí-la.

Isso é chamado de:

disconfirming evidence.


🧠 CAPÍTULO 9 — O MONSTRO CHAMADO CONFIRMATION BIAS

Seres humanos possuem uma falha interessante.

Quando acreditamos em alguma coisa, começamos involuntariamente a notar evidências que confirmam nossa crença.

O DBA diz:

Deve ser rede.

O network engineer:

Deve ser aplicação.

O desenvolvedor:

Deve ser banco.

O operador:

Deve ser o deploy.

E cada um começa a procurar evidências para seu suspeito favorito.

Uma investigação melhor pergunta:

Que resultado provaria que minha hipótese está errada?

Isso muda tudo.

Você deixa de defender uma teoria.

Começa a testá-la.


🕰️ CAPÍTULO 10 — CONSTRUA A TIMELINE

Cobb pega o quadro novamente.

Tempo é uma dimensão fundamental.

Imagine:

09:55 deploy
10:00 feature flag
10:04 erros começam
10:06 latency aumenta
10:08 retries aumentam
10:10 connection pool esgota
10:12 sistema praticamente indisponível

Agora temos uma narrativa.

Mas cuidado:

correlação não significa causalidade.

O deploy aconteceu antes do incidente.

Isso o torna um candidato importante.

Não prova que ele causou o incidente.

Talvez às 10:03 uma dependência externa tenha falhado.

Portanto:

MUDANÇA + PROXIMIDADE TEMPORAL
              ↓
           HIPÓTESE

não:

MUDANÇA
  ↓
CULPADO

💣 CAPÍTULO 11 — "NÃO MUDAMOS NADA"

Uma frase clássica de produção:

Aqui ninguém mudou nada.

Clare olha desconfiada.

Porque alguma coisa frequentemente mudou.

Talvez não o programa.

Mudanças podem incluir:

configuração
certificado
DNS
firewall
senha
token
schema
feature flag
biblioteca
dependência
infraestrutura
capacidade
tráfego

No mainframe:

LOAD MODULE
DBRM
PACKAGE
PLAN
PROC
JCL
PARMLIB
PROCLIB
LINKLIST
RACF
CICS definitions
MQ definitions
WLM policy
SMS
PTF
APAR
TCP/IP

E existe uma mudança ainda mais traiçoeira.

Nada foi alterado tecnicamente.

Ontem:

10.000 transações/hora

Hoje:

700.000 transações/hora

O software é idêntico.

O ambiente operacional não é.


🌊 CAPÍTULO 12 — QUANDO RETRY VIRA ARMA DE DESTRUIÇÃO EM MASSA

Temos:

APP
 ↓
SERVICE
 ↓
DATABASE

O database começa a responder lentamente.

A aplicação tenta novamente.

Parece sensato.

Mas suponha:

1.000 requests/s

Cada cliente tenta três vezes.

Temos potencialmente:

1.000 × 3 = 3.000 tentativas/s

A dependência, que já estava sobrecarregada, recebe mais carga.

Fica ainda mais lenta.

Mais timeouts.

Mais retries.

LENTIDÃO
   ↓
TIMEOUT
   ↓
RETRY
   ↓
MAIS CARGA
   ↓
MAIS LENTIDÃO
   ↓
MAIS TIMEOUT

Parabéns.

O mecanismo criado para aumentar resiliência agora está ajudando a derrubar o sistema.

Isso é retry amplification.


⚡ CAPÍTULO 13 — CIRCUIT BREAKER

Para resolver parte desse problema surgiu um conceito inspirado em eletricidade.

O circuit breaker.

CLIENT
   ↓
CIRCUIT BREAKER
   ↓
SERVICE

Normalmente temos estados conceituais:

CLOSED
 ↓
muitas falhas
 ↓
OPEN
 ↓
espera
 ↓
HALF-OPEN
 ↓
teste

Quando OPEN, paramos temporariamente de bombardear a dependência.

Podemos:

  • falhar rapidamente;
  • usar fallback;
  • devolver mensagem controlada;
  • permitir recuperação.

É melhor dizer rapidamente:

Serviço temporariamente indisponível.

do que deixar milhares de threads esperando 30 segundos antes de morrer.


🎲 CAPÍTULO 14 — JITTER E O EXÉRCITO DOS CLONES

Agora temos outro problema.

100.000 clientes falham às 12:00.

Todos foram programados:

WAIT 10 SECONDS
RETRY

Às 12:00:10:

██████████████████████████
100.000 RETRIES
██████████████████████████

Todos atacam juntos.

Esse tipo de fenômeno é associado ao chamado thundering herd.

Então usamos:

backoff + jitter

Em vez de todos retornarem exatamente no mesmo instante, introduzimos variação.

10.17 s
9.84 s
11.03 s
10.52 s
...

Espalhamos a carga.

Curiosamente, às vezes uma pequena dose de aleatoriedade torna sistemas distribuídos mais estáveis.


📊 CAPÍTULO 15 — OBSERVABILIDADE NÃO É TER UM DASHBOARD BONITO

As imagens apresentam quatro grupos úteis:

METRICS
LOGS
TRACES
EVENTS

Metrics

Respondem:

Quanto?

CPU
memory
RPS
latency
queue depth
error rate

Logs

Respondem:

O que aconteceu?

abend
exception
warning
message
error

Traces

Respondem:

Por onde a transação passou?

A → B → C → D

Events

Respondem:

O que aconteceu no ambiente?

deployment
restart
configuration change
scaling
certificate rotation

Juntos, eles contam uma história.


🦖 CAPÍTULO 16 — O MAINFRAME JÁ CONHECIA PARTE DESSA HISTÓRIA

Aqui nosso programador COBOL começa a sorrir.

Porque reconhece vários parentes.

No mundo moderno encontramos:

Prometheus
Grafana
OpenTelemetry
Kubernetes Events
distributed tracing
SLO

No universo IBM Z convivemos há muito tempo com coisas como:

SMF
RMF
WLM
SYSLOG
SDSF
CICS statistics
Db2 statistics
MQ monitoring

Não são equivalências perfeitas.

Mas tentam responder perguntas muito parecidas:

O que aconteceu?

Quando aconteceu?

Quanto recurso foi consumido?

Qual workload sofreu?

Quanto demorou?

Quem estava esperando?

Qual componente tornou-se gargalo?

O mundo cloud não inventou a necessidade de observar sistemas críticos.

Ele desenvolveu ferramentas e vocabulários contemporâneos para problemas que sistemas transacionais conhecem há décadas.


📈 CAPÍTULO 17 — A MÉDIA É UM MIMIC DISFARÇADO DE ESTATÍSTICA

Imagine 100 requisições.

95 respondem:

100 ms

Cinco respondem:

10 segundos

Uma média isolada pode esconder uma experiência péssima para uma parcela dos usuários.

Por isso usamos percentis:

p50
p95
p99

Simplificando:

p95 = 500 ms

significa que aproximadamente 95% das observações ficaram em 500 ms ou menos.

O p99 ajuda a enxergar a cauda.

Em arquiteturas distribuídas isso é particularmente importante.

Uma operação pode depender de:

A
├── B
├── C
├── D
└── E

Basta uma dependência apresentar tail latency alta para a experiência final piorar.


🗄️ CAPÍTULO 18 — REINICIAR O BANCO PODE ESCONDER O ASSASSINO

Restart é sedutor.

Banco lento.

Restart.

Voltou.

Chamado encerrado.

Só existe um pequeno problema.

O restart pode:

limpar conexões
liberar memória
encerrar queries
remover locks
reinicializar caches

Então imagine um connection leak:

restart
 ↓
10 conexões
 ↓
100
 ↓
500
 ↓
1000
 ↓
2000
 ↓
BOOM

Depois:

restart
 ↓
10 conexões

Você não corrigiu o problema.

Apenas reiniciou o cronômetro.


🟢 CAPÍTULO 19 — O GRÁFICO VERDE PODE ESTAR MENTINDO

Cobb coloca o pião sobre a mesa.

Ele gira.

O dashboard ficou verde.

Podemos fechar o incidente?

Não tão rápido.

Recovery não significa simplesmente "ficou verde".

Precisamos verificar:

funcionalidade
latência
erros
dados
replicação
filas
dependências
background jobs
capacidade
SLOs

Imagine:

CICS       OK
DB2        OK
CPU        OK
MQ         OK

Mas:

QUEUE DEPTH = 3.800.000

Existe uma montanha esperando para ser processada.

Ou pior:

serviço = disponível
dados = inconsistentes

O usuário consegue entrar.

Mas encontra saldo incorreto.

Isso não é recuperação.

É um incidente usando maquiagem.


🧟 CAPÍTULO 20 — O SEGUNDO MONSTRO

Clare avisa:

— Nunca presuma que derrotar um Yoma significa que acabou.

Imagine:

A → B → C

A ficou fora durante uma hora.

B acumulou backlog.

A volta.

Agora milhões de itens começam a atravessar B.

A → ███████████ → B → C

CPU dispara.

Filas crescem.

C sofre.

Nasce um secondary failure.

Por isso o fluxo correto não é:

RECOVER → CLOSE

mas:

RECOVER
 ↓
VERIFY
 ↓
MONITOR
 ↓
CLOSE

👨‍🚒 CAPÍTULO 21 — INCIDENT COMMANDER NÃO É O HERÓI QUE DIGITA MAIS RÁPIDO

Incidentes graves possuem também um problema humano.

Imagine vinte especialistas numa chamada.

Todos falam.

Todos investigam.

Todos dão ordens.

Resultado:

CHAOS++

O Incident Command System divide responsabilidades.

Podemos ter:

Incident Commander
Technical Lead
Operations Responders
Communications Lead
Scribe
Subject-Matter Experts
Stakeholders

O Incident Commander coordena.

O Technical Lead conduz investigação técnica.

Operations executa mudanças.

O Scribe registra timeline e decisões.

Communications informa interessados.

SMEs entram com conhecimento especializado.

Isso permite trabalho paralelo.

E principalmente evita que o melhor especialista técnico precise responder a cada três minutos:

Já voltou?


🔥 CAPÍTULO 22 — UMA IDEIA QUE VEIO DOS INCÊNDIOS

Aqui temos uma bela curiosidade histórica.

O Incident Command System moderno possui raízes na resposta americana a grandes incêndios florestais, particularmente a partir dos anos 1970.

O desafio possuía características familiares:

muitas equipes
muitas organizações
recursos diferentes
informação incompleta
situação mudando rapidamente
decisões urgentes

Parece uma war room de produção?

Exatamente.

A solução envolveu:

comando claro
funções definidas
coordenação
comunicação
procedimentos

Décadas depois, princípios semelhantes apareceriam na gestão de grandes incidentes tecnológicos.

Mudou o incêndio.

Agora:

kubectl get pods

está pegando fogo.


🧅 CAPÍTULO 23 — INCEPTION E A CEBOLA DA INFRAESTRUTURA

Um incidente moderno possui camadas.

BUSINESS
   ↓
APPLICATION
   ↓
RUNTIME
   ↓
CONTAINER
   ↓
KUBERNETES
   ↓
OPERATING SYSTEM
   ↓
NETWORK
   ↓
STORAGE
   ↓
HARDWARE

E ainda podemos acrescentar:

THIRD-PARTY DEPENDENCY

Cobb sorri.

— Precisamos descer mais um nível.

Esse é talvez o melhor paralelo com Inception.

O sintoma percebido pelo usuário pertence à camada superior.

A causa pode estar cinco níveis abaixo.

Mas existe uma diferença importante.

Em Inception, quanto mais profundamente entramos, mais difícil é saber se estamos sonhando.

Em produção, quanto mais profundamente investigamos sem método, mais fácil é esquecer qual problema estávamos tentando resolver.

Por isso mantenha sempre uma âncora:

CUSTOMER IMPACT

Nosso totem.


🧮 CAPÍTULO 24 — INVESTIGAR É REDUZIR INCERTEZA

Inicialmente podemos ter:

H = {
 aplicação,
 Db2,
 MQ,
 DNS,
 TLS,
 storage,
 CPU,
 memória,
 rede,
 configuração,
 deployment,
 dependência
}

Descobrimos:

DNS OK
TLS OK
CPU OK
DB2 OK

Então:

H = {
 aplicação,
 MQ,
 rede,
 configuração,
 deployment,
 dependência
}

Descobrimos que uma região funciona e outra não.

Reduzimos novamente.

Cada evidência deve eliminar possibilidades.

E aqui aparece uma conexão belíssima com teoria da informação.

Um bom teste não é aquele que produz mais dados.

É aquele que produz mais informação.

Perguntar:

"Podemos coletar mais 30 GB de logs?"

talvez seja menos útil que perguntar:

"O mesmo erro ocorre na outra região?"

Se a resposta for não, acabamos de eliminar uma enorme quantidade de hipóteses.


🧙 CAPÍTULO 25 — POR QUE O ENGENHEIRO VETERANO PARECE UM MAGO?

O iniciante vê:

HTTP 500

e pergunta:

Onde está o erro?

O veterano pergunta:

Desde quando?

Todos os usuários?

Todas as regiões?

Todos endpoints?

Qual percentual?

O que mudou?

Existe backlog?

Qual dependência?

Existem retries?

Existe saturation?

Qual caminho ainda funciona?

Dez perguntas depois, restam três suspeitos.

Isso parece intuição.

Frequentemente é experiência ensinando quais perguntas possuem maior poder discriminatório.

No mainframe acontece a mesma coisa.

O veterano pergunta:

Qual LPAR?

Qual região?

Qual transaction?

Qual job?

Qual step?

Qual dataset?

Qual subsystem?

Desde quando?

Só aqui?

O que mudou?

Sem utilizar esses nomes, ele está fazendo:

scope
blast-radius analysis
failure-domain isolation
timeline reconstruction
change correlation

Há décadas.


🗡️ CAPÍTULO 26 — CLAYMORE E O PERIGO DE "DESPERTAR" O INCIDENTE

Existe ainda uma analogia curiosa com Claymore.

Uma falha pequena nem sempre permanece pequena.

Imagine:

DEPENDÊNCIA LENTA
       ↓
    RETRIES
       ↓
CONNECTION POOL
       ↓
    SATURATION
       ↓
    TIMEOUTS
       ↓
MAIS RETRIES
       ↓
OUTROS SERVIÇOS
       ↓
CASCADING FAILURE

A falha original pode ter sido relativamente modesta.

Mas o sistema reage a ela.

E a reação transforma o incidente.

Quase como um despertar.

O monstro final pode ser muito maior do que o evento que iniciou tudo.

Essa é uma das grandes lições de sistemas distribuídos:

falhas possuem dinâmica.

Não analisamos apenas componentes.

Analisamos como componentes reagem às falhas de outros componentes.


🥚 EASTER EGG — O S0C7 QUE NÃO ERA S0C7

Às 04:21 nosso jovem programador encontra finalmente um:

IGZ0006S

— Achei!

Clare olha.

Cobb olha.

O DBA olha.

O operador olha.

Nosso herói anuncia:

— É o COBOL!

Silêncio.

O veterano pergunta:

— De que horas é esse ABEND?

Ele olha novamente.

01:43

O incidente começou:

03:17

O S0C7 não tinha relação alguma.

Era apenas um cadáver antigo encontrado no caminho.

Cobb pega o pião.

Clare guarda a espada.

E alguém escreve no chat:

       88  ROOT-CAUSE-FOUND VALUE 'Y'.

O veterano responde:

       MOVE 'N' TO ROOT-CAUSE-FOUND.

🏁 EPÍLOGO — O SISTEMA VOLTOU. MAS VOCÊ APRENDEU ALGUMA COISA?

Às 04:47 o serviço finalmente estabilizou.

Às 05:02 as filas começaram a diminuir.

Às 05:21 os percentis voltaram ao normal.

Às 05:40 os testes sintéticos passaram.

Às 06:10 ninguém observou novos erros.

Somente então o incidente foi encerrado.

Mas ainda faltava uma última etapa:

LEARN

Um bom incidente deveria produzir:

  • timeline;
  • causa raiz quando identificável;
  • fatores contribuintes;
  • impacto;
  • ações tomadas;
  • decisões;
  • pontos de observabilidade ausentes;
  • automações necessárias;
  • melhoria de runbooks;
  • novos alertas;
  • testes;
  • mecanismos preventivos.

E, principalmente, evitar uma cultura simplista de:

Quem fez isso?

Uma pergunta muito mais produtiva é:

Por que nosso sistema permitiu que isso produzisse tamanho impacto?

Talvez um humano tenha cometido um erro.

Humanos sempre cometerão erros.

A engenharia madura pergunta por que um único erro conseguiu atravessar tantas barreiras.


☕ A ÚLTIMA LIÇÃO DO BELLACOSA MAINFRAME

Se você é um programador COBOL iniciante, talvez tenha começado este artigo esperando aprender comandos.

Comandos são importantes.

Aprenda SDSF.

Aprenda CICS.

Aprenda Db2.

Aprenda MQ.

Aprenda SMF, RMF e WLM.

Entenda rede.

Entenda APIs.

Entenda observabilidade.

Mas existe uma habilidade acima delas:

aprender a investigar.

Ferramentas envelhecem.

Interfaces desaparecem.

Arquiteturas mudam.

Ontem:

3270

Hoje:

Grafana

Amanhã teremos outra coisa.

Mas algumas perguntas sobrevivem:

O que aconteceu?

Quando começou?

Quem foi afetado?

Qual o blast radius?

O que mudou?

O que ainda funciona?

Qual caminho a transação percorre?

Quais são as dependências?

Quais evidências sustentam minha hipótese?

O que provaria que estou errado?

Posso mitigar sem destruir evidências?

O serviço realmente se recuperou?

O que aprendemos?

Clare olha para nosso jovem programador.

— Não ataque todo monstro que aparecer.

Cobb completa:

— E nunca confie na primeira camada.

No monitor, todos os gráficos finalmente estão verdes.

Nosso programador olha para eles.

Antes daquela madrugada teria dito:

Resolvido.

Agora não.

Ele abre SDSF.

Confere as filas.

Verifica CICS.

Consulta Db2.

Olha MQ.

Compara os tempos.

Confirma os dados.

Revisa os logs.

Espera alguns minutos.

Somente então escreve:

SERVICE VERIFIED.
INCIDENT CLOSED.

Porque finalmente entendeu a diferença entre duas frases que parecem iguais:

O sistema voltou.

e:

Nós sabemos que o sistema se recuperou.

Entre elas existe praticamente toda a disciplina de Incident Response.

E em algum lugar do CPD, quase escondido entre milhões de registros SMF, havia um pequeno easter egg esperando o próximo programador:

       01  PRODUCTION.
           05  STATUS       PIC X(08).
           05  ROOT-CAUSE   PIC X(80).

       PROCEDURE DIVISION.

           IF STATUS = 'GREEN'
              DISPLAY
              'NAO CONFIE NO DASHBOARD AINDA'
           END-IF.

           PERFORM VERIFY-EVERYTHING.

           GOBACK.

Porque MAXCC=0000 nunca significou que o usuário está feliz.

Vagner Renato Bellacosa, IBM Champion e especialista em IBM Mainframe
IBM Z17 SYSTEM ONLINE
Sobre o autor

Vagner Renato Bellacosa

IBM Champion 2026 • Especialista em IBM Mainframe

Vagner Renato Bellacosa trabalha com IBM Mainframe desde 1988 , é IBM Champion e especialista em COBOL, CICS, Db2, z/OS e IBM Z. Compartilha experiências profissionais, conhecimento técnico, história da computação e práticas do universo mainframe para aproximar novas gerações das tecnologias que sustentam empresas, bancos e governos ao redor do mundo.

IBM Champion IBM Z COBOL CICS Db2 z/OS Mainframe desde 1988
GitHub LinkedIn
Inicializando conteúdo...