🚨 Troubleshooting

Objetivo: Identificar, diagnosticar y resolver problemas comunes y complejos con Caddy en entornos de desarrollo.

🚨 Problemas Críticos

Caddy No Inicia

🚫 Puerto 443/80 Ocupado

Síntomas:

Error: bind: address already in use
Caddy no puede iniciar

Diagnóstico:

# Identificar qué proceso usa el puerto
netstat -ano | findstr ":443"
netstat -ano | findstr ":80"

# Ver detalles del proceso
tasklist /FI "PID eq [PID_NUMBER]"

Soluciones:

# Opción 1: Terminar proceso específico
taskkill /F /PID [PID_NUMBER]

# Opción 2: Terminar todos los Caddy
Get-Process caddy | Stop-Process -Force

# Opción 3: Si es IIS ocupando puerto 80
net stop http
# Luego reconfigurar IIS en otro puerto

🔒 Problemas de Certificados SSL

Síntomas:

certificate verify failed
Navegador muestra “No seguro”
Error: tls: internal error

Soluciones:

# Regenerar todos los certificados
.\caddy.exe untrust
.\caddy.exe trust

# Limpiar cache de certificados
Remove-Item "$env:LOCALAPPDATA\Caddy\*" -Recurse -Force

# Verificar certificado específico
openssl s_client -connect mi-motor.local:443 -servername mi-motor.local

# Si persiste, verificar hosts file
notepad C:\Windows\System32\drivers\etc\hosts

🌐 DNS No Resuelve

Síntomas:

nslookup falla para dominio local
Navegador no encuentra el sitio
ERR_NAME_NOT_RESOLVED

Soluciones:

# Verificar entrada en hosts
Get-Content C:\Windows\System32\drivers\etc\hosts | Select-String "mi-motor.local"

# Si no existe, agregar:
Add-Content C:\Windows\System32\drivers\etc\hosts "127.0.0.1 mi-motor.local"

# Limpiar cache DNS
ipconfig /flushdns

# Test DNS
nslookup mi-motor.local
ping mi-motor.local

🔍 Herramientas de Diagnóstico

Script de Diagnóstico Completo

param(
    [string]$Domain = "mi-motor.local",
    [string]$CaddyPath = "C:\tools\caddy",
    [switch]$Verbose
)

$ErrorActionPreference = "Continue"
$results = @()

function Add-Result($Test, $Status, $Message, $Details = "") {
    $results += [PSCustomObject]@{
        Test = $Test
        Status = $Status
        Message = $Message
        Details = $Details
    }
}

function Write-TestResult($Test, $Status, $Message) {
    $color = switch ($Status) {
        "PASS" { "Green" }
        "FAIL" { "Red" }
        "WARN" { "Yellow" }
    }
    $icon = switch ($Status) {
        "PASS" { "✅" }
        "FAIL" { "❌" }
        "WARN" { "⚠️" }
    }
    Write-Host "$icon $Test`: $Message" -ForegroundColor $color
}

Write-Host "🔍 Diagnóstico Completo de Caddy para $Domain" -ForegroundColor Cyan
Write-Host "=" * 60

# 1. Verificar proceso Caddy
try {
    $caddyProcess = Get-Process -Name "caddy" -ErrorAction Stop
    Add-Result "Proceso Caddy" "PASS" "Ejecutándose (PID: $($caddyProcess.Id))" "Memoria: $([math]::Round($caddyProcess.WorkingSet64/1MB, 2)) MB"
    Write-TestResult "Proceso Caddy" "PASS" "Ejecutándose (PID: $($caddyProcess.Id))"
} catch {
    Add-Result "Proceso Caddy" "FAIL" "No está ejecutándose" $_.Exception.Message
    Write-TestResult "Proceso Caddy" "FAIL" "No está ejecutándose"
}

# 2. Verificar puertos críticos
$ports = @(80, 443)
foreach ($port in $ports) {
    try {
        $connection = Test-NetConnection -ComputerName "localhost" -Port $port -InformationLevel Quiet -WarningAction SilentlyContinue
        if ($connection) {
            Add-Result "Puerto $port" "PASS" "Abierto y accesible"
            Write-TestResult "Puerto $port" "PASS" "Abierto"
        } else {
            # Verificar qué proceso usa el puerto
            $netstat = netstat -ano | Select-String ":$port "
            Add-Result "Puerto $port" "FAIL" "Cerrado o inaccesible" $netstat
            Write-TestResult "Puerto $port" "FAIL" "Cerrado"
        }
    } catch {
        Add-Result "Puerto $port" "FAIL" "Error verificando puerto" $_.Exception.Message
        Write-TestResult "Puerto $port" "FAIL" "Error en verificación"
    }
}

# 3. Verificar resolución DNS
try {
    $dns = Resolve-DnsName $Domain -ErrorAction Stop
    Add-Result "DNS" "PASS" "Resuelve a $($dns.IPAddress)"
    Write-TestResult "DNS" "PASS" "Resuelve correctamente"
} catch {
    # Verificar hosts file
    $hostsContent = Get-Content "C:\Windows\System32\drivers\etc\hosts" -ErrorAction SilentlyContinue
    $hostsEntry = $hostsContent | Select-String $Domain
    if ($hostsEntry) {
        Add-Result "DNS" "WARN" "No resuelve DNS pero existe en hosts" $hostsEntry
        Write-TestResult "DNS" "WARN" "Solo en hosts file"
    } else {
        Add-Result "DNS" "FAIL" "No resuelve y no está en hosts" $_.Exception.Message
        Write-TestResult "DNS" "FAIL" "No configurado"
    }
}

# 4. Test conectividad HTTP
try {
    $httpResponse = Invoke-WebRequest -Uri "http://$Domain" -UseBasicParsing -TimeoutSec 10 -ErrorAction Stop
    Add-Result "HTTP" "PASS" "Responde $($httpResponse.StatusCode)" "Content-Length: $($httpResponse.Content.Length)"
    Write-TestResult "HTTP" "PASS" "Responde $($httpResponse.StatusCode)"
} catch {
    Add-Result "HTTP" "FAIL" "No responde" $_.Exception.Message
    Write-TestResult "HTTP" "FAIL" "No responde"
}

# 5. Test conectividad HTTPS
try {
    $httpsResponse = Invoke-WebRequest -Uri "https://$Domain" -UseBasicParsing -TimeoutSec 10 -SkipCertificateCheck -ErrorAction Stop
    Add-Result "HTTPS" "PASS" "Responde $($httpsResponse.StatusCode)" "SSL OK"
    Write-TestResult "HTTPS" "PASS" "Responde $($httpsResponse.StatusCode)"
} catch {
    Add-Result "HTTPS" "FAIL" "No responde" $_.Exception.Message
    Write-TestResult "HTTPS" "FAIL" "No responde"
}

# 6. Verificar configuración Caddy
$caddyfile = Join-Path $CaddyPath "Caddyfile"
if (Test-Path $caddyfile) {
    try {
        $caddyExe = Join-Path $CaddyPath "caddy.exe"
        $validation = & $caddyExe validate --config $caddyfile 2>&1
        if ($LASTEXITCODE -eq 0) {
            Add-Result "Configuración" "PASS" "Sintaxis válida"
            Write-TestResult "Configuración" "PASS" "Sintaxis válida"
        } else {
            Add-Result "Configuración" "FAIL" "Sintaxis inválida" $validation
            Write-TestResult "Configuración" "FAIL" "Sintaxis inválida"
        }
    } catch {
        Add-Result "Configuración" "FAIL" "Error validando" $_.Exception.Message
        Write-TestResult "Configuración" "FAIL" "Error validando"
    }
} else {
    Add-Result "Configuración" "FAIL" "Caddyfile no encontrado" $caddyfile
    Write-TestResult "Configuración" "FAIL" "Caddyfile no encontrado"
}

# 7. Verificar logs recientes
$logPath = Join-Path $CaddyPath "caddy.log"
if (Test-Path $logPath) {
    $recentErrors = Get-Content $logPath -Tail 20 | Select-String -Pattern "error|failed|timeout" -CaseSensitive:$false
    if ($recentErrors) {
        Add-Result "Logs" "WARN" "Errores recientes encontrados" ($recentErrors -join "`n")
        Write-TestResult "Logs" "WARN" "$($recentErrors.Count) errores recientes"
    } else {
        Add-Result "Logs" "PASS" "Sin errores recientes"
        Write-TestResult "Logs" "PASS" "Sin errores recientes"
    }
} else {
    Add-Result "Logs" "WARN" "Archivo de logs no encontrado" $logPath
    Write-TestResult "Logs" "WARN" "Sin archivo de logs"
}

# 8. Test específicos de handlers
$handlers = @(
    @{ Name = "Offer Handler"; Path = "/offer" }
    @{ Name = "Checkout Handler"; Path = "/chk" }
    @{ Name = "Purchase Handler"; Path = "/purchase" }
)

foreach ($handler in $handlers) {
    try {
        $url = "https://$Domain$($handler.Path)"
        $response = Invoke-WebRequest -Uri $url -UseBasicParsing -TimeoutSec 5 -SkipCertificateCheck -ErrorAction Stop
        Add-Result $handler.Name "PASS" "Responde $($response.StatusCode)"
        Write-TestResult $handler.Name "PASS" "OK"
    } catch {
        if ($_.Exception.Message -like "*404*") {
            Add-Result $handler.Name "WARN" "Handler no configurado (404)"
            Write-TestResult $handler.Name "WARN" "No configurado"
        } else {
            Add-Result $handler.Name "FAIL" "Error de conexión" $_.Exception.Message
            Write-TestResult $handler.Name "FAIL" "Error"
        }
    }
}

# Resumen final
Write-Host "`n" + "=" * 60
$passCount = ($results | Where-Object { $_.Status -eq "PASS" }).Count
$failCount = ($results | Where-Object { $_.Status -eq "FAIL" }).Count
$warnCount = ($results | Where-Object { $_.Status -eq "WARN" }).Count

Write-Host "📊 Resumen:" -ForegroundColor Cyan
Write-Host "  ✅ Exitosos: $passCount" -ForegroundColor Green
Write-Host "  ❌ Fallidos: $failCount" -ForegroundColor Red
Write-Host "  ⚠️  Advertencias: $warnCount" -ForegroundColor Yellow

if ($failCount -eq 0) {
    Write-Host "`n🎉 ¡Sistema funcionando correctamente!" -ForegroundColor Green
} elseif ($failCount -le 2) {
    Write-Host "`n⚠️  Sistema con problemas menores" -ForegroundColor Yellow
} else {
    Write-Host "`n🚨 Sistema con problemas críticos" -ForegroundColor Red
}

if ($Verbose) {
    Write-Host "`n📋 Detalles completos:" -ForegroundColor Cyan
    $results | Format-Table Test, Status, Message, Details -AutoSize
}

Write-Host "`n🏁 Diagnóstico completado" -ForegroundColor Cyan
return $results

param(
    [string]$LogPath = "C:\tools\caddy\caddy.log",
    [string]$Filter = "",
    [int]$Lines = 50,
    [switch]$ErrorsOnly,
    [switch]$ShowTimestamp
)

# Crear archivo de logs si no existe
if (-not (Test-Path $LogPath)) {
    $logDir = Split-Path $LogPath -Parent
    if (-not (Test-Path $logDir)) {
        New-Item -ItemType Directory -Path $logDir -Force
    }

    Write-Warning "Archivo de logs no encontrado. Iniciando Caddy con logging..."
    $caddyDir = Split-Path $LogPath -Parent
    Start-Process powershell -ArgumentList "-Command", "cd '$caddyDir'; .\caddy.exe run --config .\Caddyfile > caddy.log 2>&1" -WindowStyle Normal

    # Esperar a que se cree el archivo
    $timeout = 30
    while (-not (Test-Path $LogPath) -and $timeout -gt 0) {
        Start-Sleep 1
        $timeout--
    }

    if (-not (Test-Path $LogPath)) {
        Write-Error "No se pudo crear el archivo de logs después de 30 segundos"
        exit 1
    }
}

# Configurar filtros
if ($ErrorsOnly) {
    $Filter = "error|failed|timeout|exception|panic|fatal"
}

Write-Host "📋 Monitoreando logs de Caddy..." -ForegroundColor Cyan
Write-Host "Archivo: $LogPath" -ForegroundColor Yellow
if ($Filter) {
    Write-Host "Filtro: $Filter" -ForegroundColor Yellow
}
Write-Host "Líneas iniciales: $Lines" -ForegroundColor Yellow
Write-Host "Presiona Ctrl+C para salir`n" -ForegroundColor Gray

# Función para formatear líneas de log
function Format-LogLine($line) {
    if ($ShowTimestamp) {
        return "[$(Get-Date -Format 'HH:mm:ss')] $line"
    }

    # Colorear según tipo de mensaje
    if ($line -match "error|failed|exception") {
        Write-Host $line -ForegroundColor Red
    } elseif ($line -match "warn|warning") {
        Write-Host $line -ForegroundColor Yellow
    } elseif ($line -match "info|start|listen") {
        Write-Host $line -ForegroundColor Green
    } elseif ($line -match "debug|trace") {
        Write-Host $line -ForegroundColor Gray
    } else {
        Write-Host $line
    }
}

try {
    if ($Filter) {
        Get-Content $LogPath -Tail $Lines -Wait | Where-Object { $_ -match $Filter } | ForEach-Object { Format-LogLine $_ }
    } else {
        Get-Content $LogPath -Tail $Lines -Wait | ForEach-Object { Format-LogLine $_ }
    }
} catch {
    Write-Host "Error monitoreando logs: $($_.Exception.Message)" -ForegroundColor Red
}

param(
    [string]$Domain = "mi-motor.local",
    [int]$Port = 443,
    [int]$Timeout = 10
)

Write-Host "🌐 Test de Conectividad Completo para $Domain`:$Port" -ForegroundColor Cyan

# 1. Test básico de ping
Write-Host "`n1. Test Ping:" -ForegroundColor Yellow
try {
    $ping = Test-Connection $Domain -Count 1 -Quiet
    if ($ping) {
        Write-Host "✅ Ping exitoso" -ForegroundColor Green
    } else {
        Write-Host "❌ Ping falló" -ForegroundColor Red
    }
} catch {
    Write-Host "❌ Error en ping: $($_.Exception.Message)" -ForegroundColor Red
}

# 2. Test de puerto específico
Write-Host "`n2. Test Puerto $Port`:" -ForegroundColor Yellow
$portTest = Test-NetConnection -ComputerName $Domain -Port $Port -InformationLevel Detailed
Write-Host "  Estado: $(if($portTest.TcpTestSucceeded){'✅ Abierto'}else{'❌ Cerrado'})"
Write-Host "  Latencia: $($portTest.PingReplyDetails.RoundtripTime)ms"

# 3. Test DNS detallado
Write-Host "`n3. Test DNS:" -ForegroundColor Yellow
try {
    $dnsResult = Resolve-DnsName $Domain -Type A
    Write-Host "✅ DNS resuelve a: $($dnsResult.IPAddress)" -ForegroundColor Green
} catch {
    Write-Host "❌ DNS no resuelve" -ForegroundColor Red

    # Verificar hosts file
    $hostsFile = "C:\Windows\System32\drivers\etc\hosts"
    $hostsEntry = Get-Content $hostsFile | Select-String $Domain
    if ($hostsEntry) {
        Write-Host "⚠️  Entrada encontrada en hosts file: $hostsEntry" -ForegroundColor Yellow
    } else {
        Write-Host "❌ No encontrado en DNS ni en hosts file" -ForegroundColor Red
    }
}

# 4. Test SSL (si es puerto 443)
if ($Port -eq 443) {
    Write-Host "`n4. Test SSL:" -ForegroundColor Yellow
    try {
        $req = [System.Net.WebRequest]::Create("https://$Domain")
        $req.Timeout = $Timeout * 1000
        $req.Method = "HEAD"
        $response = $req.GetResponse()

        Write-Host "✅ SSL OK - Status: $($response.StatusCode)" -ForegroundColor Green

        # Detalles del certificado
        $cert = $req.ServicePoint.Certificate
        if ($cert) {
            Write-Host "  Certificado emitido para: $($cert.Subject)"
            Write-Host "  Válido hasta: $($cert.GetExpirationDateString())"
        }

        $response.Close()
    } catch {
        Write-Host "❌ Error SSL: $($_.Exception.Message)" -ForegroundColor Red
    }
}

# 5. Test específico de handlers
Write-Host "`n5. Test Handlers:" -ForegroundColor Yellow
$testPaths = @("/offer", "/chk", "/purchase", "/wibble")

foreach ($path in $testPaths) {
    try {
        $url = "https://$Domain$path"
        $response = Invoke-WebRequest -Uri $url -Method HEAD -UseBasicParsing -TimeoutSec $Timeout -SkipCertificateCheck
        Write-Host "  $path`: ✅ $($response.StatusCode)" -ForegroundColor Green
    } catch {
        $status = if ($_.Exception.Response) { $_.Exception.Response.StatusCode } else { "Error" }
        $color = if ($status -eq 404) { "Yellow" } else { "Red" }
        $icon = if ($status -eq 404) { "⚠️" } else { "❌" }
        Write-Host "  $path`: $icon $status" -ForegroundColor $color
    }
}

Write-Host "`n🏁 Test completado" -ForegroundColor Cyan

🧩 Problemas por Categoría

Configuración y Sintaxis

Error: Caddyfile:X: unrecognized directive

# ❌ Problema
mi-motor.local {
    invalid_directive value  # ← Directiva inexistente
}

# ✅ Solución
mi-motor.local {
    reverse_proxy localhost:80
}

Error: parsing caddyfile tokens: too many open blocks

# ❌ Problema - llaves no balanceadas
mi-motor.local {
    handle /offer {
        reverse_proxy localhost:5250
    # ← Falta cerrar llave
}

# ✅ Solución
mi-motor.local {
    handle /offer {
        reverse_proxy localhost:5250
    }
}

Error: site block may only contain a hostname

# ❌ Problema
mi-motor.local/path {  # ← No se permite path en site block
    reverse_proxy localhost:80
}

# ✅ Solución
mi-motor.local {
    handle /path {
        reverse_proxy localhost:80
    }
}

Error: no such file or directory: handlers/offer.conf

# Diagnóstico
Get-ChildItem handlers/  # Verificar si existe el archivo
Get-Location             # Verificar directorio actual

# Solución: Crear archivo faltante
New-Item -ItemType Directory -Path handlers -Force
@"
handle /offer {
    reverse_proxy localhost:5250
}
"@ | Out-File -FilePath handlers/offer.conf -Encoding UTF8

Error: import path contains invalid characters

# ❌ Problema
import handlers\offer.conf  # ← Backslash en Windows

# ✅ Solución
import handlers/offer.conf  # ← Forward slash siempre

Error: header directive missing field name

# ❌ Problema
reverse_proxy localhost:80 {
    header_up   # ← Falta nombre del header
}

# ✅ Solución
reverse_proxy localhost:80 {
    header_up Host mi-motor.local
    header_up x-origin-site mi-motor.local
}

Headers no se están aplicando

# Diagnóstico con curl
curl -I -H "Host: mi-motor.local" https://mi-motor.local/offer

# Verificar headers en logs
.\watch-logs.ps1 -Filter "header|host"

# Test específico
Invoke-WebRequest -Uri "https://mi-motor.local/offer" -Headers @{"Host"="mi-motor.local"} -UseBasicParsing

Problemas de Red y Conectividad

Error: upstream connect error or disconnect/reset

# Problema: Backend no responde
# Diagnóstico
Test-NetConnection localhost -Port 5250

# Solución: Aumentar timeouts
reverse_proxy localhost:5250 {
    timeout 30s
    dial_timeout 10s
    read_timeout 30s
    write_timeout 30s
}

Error: context deadline exceeded

# Solución: Configurar timeouts específicos por handler
handle /offer {
    reverse_proxy test-landings-api.XXXXX.com {
        timeout 60s        # ← Timeout total
        dial_timeout 15s   # ← Tiempo para conectar
        header_up Host test-landings-api.XXXXX.com
    }
}

Error: no such host

# Diagnóstico completo
nslookup test-landings-api.XXXXX.com
ping test-landings-api.XXXXX.com

# Si falla, verificar conectividad
Test-NetConnection test-landings-api.XXXXX.com -Port 443

# Alternativa: usar IP directa temporalmente
reverse_proxy 192.168.1.100:443 {
    header_up Host test-landings-api.XXXXX.com
}

Error: TLS handshake timeout

# Solución: Configurar TLS específico
reverse_proxy https://external-api.com {
    transport http {
        tls_insecure_skip_verify  # ← Solo para desarrollo
        tls_timeout 30s
    }
}

Error: CORS en navegador

# Solución: Configurar headers CORS
handle /api/* {
    header Access-Control-Allow-Origin "*"
    header Access-Control-Allow-Methods "GET, POST, PUT, DELETE, OPTIONS"
    header Access-Control-Allow-Headers "Content-Type, Authorization"

    # Manejar preflight requests
    @options method OPTIONS
    respond @options 200

    reverse_proxy api-backend.com
}

Problemas de Performance

Conexiones Lentas

Optimizar performance

{
    # Configuración global para performance
    admin off  # ← Deshabilitar admin API si no se usa
    auto_https disable_redirects

    # Limits globales
    servers {
        max_header_size 16KB
        read_timeout 30s
        write_timeout 30s
        idle_timeout 120s
    }
}

mi-motor.local {
    # Compresión para responses grandes
    encode gzip

    # Cache headers para assets estáticos
    @static path *.css *.js *.png *.jpg *.ico
    header @static Cache-Control "public, max-age=86400"

    reverse_proxy localhost:80 {
        # Connection pooling
        keepalive 2m
        keepalive_idle_conns 10
    }
}