Metricas e Desempenho de Redes

Unidades comuns:
  1 Kbps  = 1.000 bps          (mil)
  1 Mbps  = 1.000.000 bps      (milhao)
  1 Gbps  = 1.000.000.000 bps  (bilhao)

Exemplos de largura de banda:
  Wi-Fi 6 (802.11ax):  ~1-10 Gbps (teorico)
  Ethernet (Cat6):     1 Gbps ou 10 Gbps
  Fibra otica:         100 Gbps+
  4G LTE:              ~100 Mbps
  5G:                  ~1-10 Gbps

Latencia total = d_proc + d_fila + d_trans + d_prop

d_proc  = Atraso de processamento
          Tempo para examinar o cabecalho e decidir para onde encaminhar
          Tipicamente: microsegundos

d_fila  = Atraso de fila (queueing delay)
          Tempo esperando na fila do roteador
          Variavel: depende do trafego (pode ser 0 ou centenas de ms)

d_trans = Atraso de transmissao
          Tempo para colocar todos os bits do pacote no link
          = L / R  (L = tamanho do pacote, R = bandwidth do link)

d_prop  = Atraso de propagacao
          Tempo para o sinal viajar pelo meio fisico
          = d / s  (d = distancia, s = velocidade de propagacao)
          Fibra: s ≈ 2 x 10^8 m/s  (2/3 da velocidade da luz)

import time
import requests

# Medindo throughput de um download
url = "https://speed.cloudflare.com/__down?bytes=10000000"  # 10 MB

start = time.time()
response = requests.get(url)
elapsed = time.time() - start

bytes_received = len(response.content)
throughput_bps = (bytes_received * 8) / elapsed
throughput_mbps = throughput_bps / 1_000_000

print(f"Bytes: {bytes_received:,}")
print(f"Tempo: {elapsed:.2f}s")
print(f"Throughput: {throughput_mbps:.1f} Mbps")

# Calculando os componentes de atraso

# Parametros
L = 1500 * 8       # Tamanho do pacote: 1500 bytes = 12000 bits (MTU padrao)
R = 100e6           # Bandwidth do link: 100 Mbps
d = 5000e3          # Distancia: 5000 km (ex: SP a NY)
s = 2e8             # Velocidade em fibra: 2/3 da luz
d_proc = 0.00001   # Processamento: 10 microsegundos
d_fila = 0.002     # Fila: 2 ms (estimativa)

# Calculos
d_trans = L / R                 # Transmissao
d_prop = d / s                  # Propagacao
d_total = d_proc + d_fila + d_trans + d_prop

print(f"Transmissao: {d_trans*1000:.3f} ms")
print(f"Propagacao:  {d_prop*1000:.1f} ms")
print(f"Total:       {d_total*1000:.1f} ms")

# Resultado:
# Transmissao: 0.120 ms  (rapido — link de 100 Mbps)
# Propagacao:  25.0 ms   (dominante — 5000 km)
# Total:       27.1 ms   (one-way)
# RTT ≈ 54.2 ms          (ida + volta)

A ---[100 Mbps]--- R1 ---[10 Mbps]--- R2 ---[1 Gbps]--- B
                          ^^^^^^^^^
                          GARGALO

Throughput maximo A->B = 10 Mbps (limitado pelo link mais lento)

E como um encanamento:
  =====[grosso]=====--[fino]--=====[grosso]=====
  A vazao maxima e definida pelo trecho mais estreito.

import subprocess
import re
import statistics

def measure_rtt(host, count=10):
    """Mede RTT usando ping e calcula estatisticas."""
    result = subprocess.run(
        ["ping", "-c", str(count), host],
        capture_output=True, text=True
    )

    # Extrair tempos de RTT
    times = [float(m) for m in
             re.findall(r"time=(\d+\.?\d*)", result.stdout)]

    if times:
        print(f"Host: {host}")
        print(f"  Min RTT:    {min(times):.1f} ms")
        print(f"  Max RTT:    {max(times):.1f} ms")
        print(f"  Media RTT:  {statistics.mean(times):.1f} ms")
        print(f"  Jitter:     {statistics.stdev(times):.1f} ms")
        print(f"  Perda:      {(count - len(times))/count*100:.0f}%")

measure_rtt("google.com")
measure_rtt("8.8.8.8")

Metrica de Rede          Analogia harness.os
───────────────          ────────────────────
Bandwidth                Token window size (max tokens por request)
Latency                  Tempo de resposta do MCP tool call
Throughput               Tokens uteis processados por minuto
Packet loss              Chamadas MCP que falharam / timeout
Jitter                   Variacao na latencia entre tool calls
RTT                      Tempo ida+volta de um tool call
Bottleneck               Componente mais lento (Neon query? LLM inference?)
Cache hit rate           Prompt cache hit rate (% de tokens cacheados)

import time

def measure_mcp_latency(tool_fn, *args, iterations=5):
    """Mede latencia de chamadas MCP tool."""
    latencies = []
    for _ in range(iterations):
        start = time.perf_counter()
        result = tool_fn(*args)
        elapsed = time.perf_counter() - start
        latencies.append(elapsed * 1000)  # ms

    print(f"MCP Tool Call Latency:")
    print(f"  Min:   {min(latencies):.1f} ms")
    print(f"  Max:   {max(latencies):.1f} ms")
    print(f"  Media: {sum(latencies)/len(latencies):.1f} ms")
    return latencies