Broken Pipe #

import signal
import sys
import errno

# Pendekatan 1: Ignore SIGPIPE (umum untuk CLI tools)
# Mencegah proses terminate ketika pipe ditutup oleh pembaca
signal.signal(signal.SIGPIPE, signal.SIG_IGN)

# Pendekatan 2: Handle BrokenPipeError secara eksplisit
def safe_write(data: str):
    try:
        print(data)
        sys.stdout.flush()
    except BrokenPipeError:
        # Pembaca sudah menutup pipe — ini OK untuk CLI tools
        # Keluar dengan kode yang tepat
        sys.exit(0)
    except IOError as e:
        if e.errno == errno.EPIPE:
            sys.exit(0)
        raise  # re-raise error lain yang tidak expected

# Pendekatan 3: Untuk script yang pipe output-nya besar
# Ini adalah pola yang paling robust untuk Python CLI
def main():
    try:
        for item in generate_large_output():
            print(item)
    except BrokenPipeError:
        # Hapus stderr untuk menghindari "BrokenPipeError" di terminal
        # ketika user menggunakan | head atau | less
        sys.stderr.close()
        sys.exit(0)

# Mengapa stderr.close() sebelum exit:
# Jika kamu tidak close stderr, Python akan mencoba flush stderr
# saat exit dan bisa menghasilkan error tambahan yang membingungkan

# Di Django/Flask: biasanya tidak perlu handle karena framework menangani
# BrokenPipeError yang berasal dari client disconnect

# Penanganan di web server context — client disconnect

import socket
from contextlib import suppress

def send_response(client_socket, data: bytes):
    """
    Kirim response ke client dengan handling untuk client disconnect.
    """
    try:
        client_socket.sendall(data)
    except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError) as e:
        # Client menutup koneksi sebelum response selesai dikirim
        # Ini normal — log di level DEBUG, bukan ERROR
        logger.debug(
            "Client disconnected before response completed",
            extra={'error': str(e), 'client': client_socket.getpeername()}
        )
    except socket.error as e:
        if e.errno == errno.EPIPE:
            logger.debug("EPIPE: client disconnected")
        else:
            # Error socket yang tidak expected — log sebagai ERROR
            logger.error(f"Socket error: {e}")
            raise

package main

import (
    "errors"
    "io"
    "net"
    "syscall"
    "log"
    "os"
)

// Cek apakah error adalah broken pipe
func isBrokenPipe(err error) bool {
    if err == nil {
        return false
    }
    // Cek berbagai bentuk broken pipe error di Go
    if errors.Is(err, syscall.EPIPE) {
        return true
    }
    if errors.Is(err, io.ErrClosedPipe) {
        return true
    }
    // Untuk network error
    var netErr *net.OpError
    if errors.As(err, &netErr) {
        if errors.Is(netErr.Err, syscall.EPIPE) {
            return true
        }
    }
    return false
}

// Handler HTTP yang menangani client disconnect
func handleRequest(w http.ResponseWriter, r *http.Request) {
    data := generateLargeResponse()

    _, err := w.Write(data)
    if err != nil {
        if isBrokenPipe(err) {
            // Client disconnect — log debug saja
            log.Printf("DEBUG: client disconnected: %v", err)
            return
        }
        // Error lain yang perlu diperhatikan
        log.Printf("ERROR: write failed: %v", err)
    }
}

// Menulis ke stdout dengan handling broken pipe
// (untuk CLI tools yang output-nya di-pipe)
func writeToStdout(lines []string) {
    for _, line := range lines {
        _, err := fmt.Println(line)
        if err != nil {
            if isBrokenPipe(err) {
                // Pembaca menutup pipe — exit normal
                os.Exit(0)
            }
            log.Fatalf("Write error: %v", err)
        }
    }
}

// Node.js — stdout broken pipe (umum di CLI tools)
process.stdout.on('error', (err) => {
    if (err.code === 'EPIPE') {
        // Output di-pipe ke proses yang sudah selesai (misal: | head -5)
        // Exit dengan code 0 — ini adalah perilaku yang diharapkan
        process.exit(0)
    }
    // Error lain — propagate
    throw err
})

// Express.js — client disconnect saat streaming response
app.get('/large-data', (req, res) => {
    const stream = generateLargeDataStream()

    req.on('close', () => {
        // Client menutup koneksi
        stream.destroy()
        logger.debug('Client disconnected, stream destroyed')
    })

    stream.on('error', (err) => {
        logger.error('Stream error:', err)
    })

    stream.pipe(res)
})

// HTTP server — handle write setelah client disconnect
const server = http.createServer((req, res) => {
    // Cek apakah koneksi masih aktif sebelum write
    if (res.socket && res.socket.destroyed) {
        return // Jangan coba write ke socket yang sudah destroyed
    }

    res.on('error', (err) => {
        if (err.code === 'EPIPE' || err.code === 'ECONNRESET') {
            logger.debug('Client disconnected:', err.message)
        } else {
            logger.error('Response error:', err)
        }
    })

    res.end(generateResponse())
})

# Konfigurasi logging yang tepat untuk Gunicorn (Python WSGI server)

# gunicorn.conf.py
errorlog = '-'
loglevel = 'info'

# Gunicorn sudah menangani broken pipe dari client disconnect
# dan tidak log sebagai error — tapi beberapa versi perlu konfigurasi

# Untuk menghapus broken pipe dari access log Gunicorn:
# Buat custom logger yang filter broken pipe

import logging

class BrokenPipeFilter(logging.Filter):
    def filter(self, record):
        # Filter out broken pipe warning dari gunicorn
        return 'broken pipe' not in record.getMessage().lower()

# Di konfigurasi aplikasi:
gunicorn_error_logger = logging.getLogger('gunicorn.error')
gunicorn_error_logger.addFilter(BrokenPipeFilter())

import signal
import threading
import time

class GracefulServer:
    def __init__(self):
        self._shutdown = threading.Event()
        self._active_requests = 0
        self._lock = threading.Lock()

        # Handle SIGTERM untuk graceful shutdown
        signal.signal(signal.SIGTERM, self._handle_sigterm)
        signal.signal(signal.SIGINT, self._handle_sigterm)

    def _handle_sigterm(self, signum, frame):
        """Mulai graceful shutdown saat menerima SIGTERM."""
        logger.info("Received shutdown signal, starting graceful shutdown...")
        self._shutdown.set()

    def handle_request(self, request):
        """Handle satu request dengan tracking untuk graceful shutdown."""
        with self._lock:
            if self._shutdown.is_set():
                # Tolak request baru saat shutdown
                return {'status': 503, 'body': 'Service shutting down'}
            self._active_requests += 1

        try:
            return process_request(request)
        finally:
            with self._lock:
                self._active_requests -= 1

    def wait_for_shutdown(self, timeout: int = 30):
        """
        Tunggu semua request selesai sebelum exit.
        Mencegah broken pipe ke client yang sedang aktif.
        """
        self._shutdown.wait()  # tunggu shutdown signal

        deadline = time.time() + timeout
        while time.time() < deadline:
            with self._lock:
                if self._active_requests == 0:
                    break
            logger.info(f"Waiting for {self._active_requests} active requests...")
            time.sleep(0.5)

        if self._active_requests > 0:
            logger.warning(
                f"Shutdown timeout: {self._active_requests} requests still active"
            )

        logger.info("Server shutdown complete")

# Kubernetes deployment — graceful shutdown configuration

apiVersion: apps/v1
kind: Deployment
spec:
  template:
    spec:
      # Berikan waktu untuk graceful shutdown sebelum pod di-kill
      terminationGracePeriodSeconds: 60  # default 30 detik

      containers:
        - name: app
          lifecycle:
            preStop:
              exec:
                # Tunggu 10 detik sebelum container mulai shutdown
                # Memberi waktu untuk load balancer remove pod dari rotation
                command: ["/bin/sleep", "10"]

# Mendeteksi dan menginvestigasi broken pipe

# 1. Cek log untuk broken pipe
grep -i "broken pipe\|EPIPE\|SIGPIPE" /var/log/app/error.log

# 2. Cek apakah proses menerima SIGPIPE
strace -e signal -p <PID> 2>&1 | grep SIGPIPE

# 3. Monitor file descriptor suatu proses
lsof -p <PID>   # lihat semua fd yang terbuka
# Periksa apakah ada pipe yang salah ujungnya sudah tidak ada

# 4. Cek network connection state
ss -tp          # TCP connections dengan proses yang terkait
# Perhatikan state CLOSE_WAIT — bisa jadi sumber broken pipe

# 5. Monitor secara real-time dengan SystemTap atau eBPF
# (advanced - membutuhkan kernel support)
# bpftrace -e 'kprobe:pipe_write { ... }'

# 6. Reproduksi broken pipe secara terkontrol untuk testing
# Terminal 1: jalankan writer
python3 -c "
import time, sys
for i in range(100):
    print(f'line {i}')
    time.sleep(0.1)
" | head -3

# Terminal 2: lihat behavior
# head -3 membaca 3 baris lalu exit
# Python script mendapat SIGPIPE/BrokenPipeError

# ✗ Anti-pattern 1: Log broken pipe sebagai ERROR
# Mengakibatkan ribuan false positive di log dan alert yang tidak perlu
logger.error("Broken pipe error!")  # JANGAN untuk client disconnect

# ✓ Solusi: log sebagai DEBUG untuk client disconnect yang expected
logger.debug("Client disconnected (EPIPE) - normal behavior")

# ✗ Anti-pattern 2: Tidak handle SIGPIPE, biarkan proses crash
# CLI tool tanpa signal handling crash saat output di-pipe ke | head
def generate_report():
    for line in huge_dataset:
        print(line)  # crash dengan SIGPIPE jika | head -10 digunakan

# ✓ Solusi: handle BrokenPipeError di CLI tools
try:
    for line in huge_dataset:
        print(line)
except BrokenPipeError:
    sys.stderr.close()
    sys.exit(0)

# ✗ Anti-pattern 3: Ignore SIGPIPE secara global tanpa pertimbangan
# signal(SIGPIPE, SIG_IGN) di semua kode
# Bisa menyebabkan proses terus berjalan padahal tidak ada yang membaca
# dan loop menulis tanpa henti ke /dev/null

# ✓ Solusi: handle EPIPE setelah SIG_IGN secara eksplisit
signal.signal(signal.SIGPIPE, signal.SIG_IGN)
# Sekarang HARUS cek return value write() dan errno

# ✗ Anti-pattern 4: Tidak ada graceful shutdown
# Pod di-kill langsung → semua request yang aktif dapat broken pipe
# ✓ Solusi: terminationGracePeriodSeconds + preStop hook di Kubernetes

# ✗ Anti-pattern 5: Alert on-call untuk setiap broken pipe
# Broken pipe dari client disconnect bisa ribuan per hari di aplikasi yang sehat
# ✓ Solusi: bedakan antara "broken pipe dari client disconnect" (normal)
#   dengan "broken pipe karena bug internal" (perlu alert)