Broken Pipe #

package main

import (
	"errors"
	"fmt"
	"log"
	"os"
	"os/signal"
	"syscall"
)

// Pendekatan 1: Ignore SIGPIPE (umum untuk CLI tools)
// Mencegah proses terminate ketika pipe ditutup oleh pembaca
func ignoreSigpipe() {
	signal.Ignore(syscall.SIGPIPE)
}

// Pendekatan 2: Handle broken pipe secara eksplisit
func safeWrite(data string) {
	_, err := fmt.Println(data)
	if err != nil {
		if errors.Is(err, syscall.EPIPE) {
			// Pembaca sudah menutup pipe — ini OK untuk CLI tools
			// Keluar dengan kode yang tepat
			os.Exit(0)
		}
		log.Fatalf("write error: %v", err)
	}
}

// Pendekatan 3: Untuk script dengan output yang besar
// Ini pola yang paling robust untuk CLI tools
func main() {
	for item := range generateLargeOutput() {
		fmt.Println(item)
	}
}

// Menangani client disconnect saat mengirim response
func sendResponse(conn net.Conn, data []byte) {
	_, err := conn.Write(data)
	if err != nil {
		if errors.Is(err, syscall.EPIPE) ||
			errors.Is(err, syscall.ECONNRESET) ||
			errors.Is(err, syscall.ECONNABORTED) {
			// Client menutup koneksi sebelum response selesai dikirim
			// Ini normal — log di level DEBUG, bukan ERROR
			log.Printf("DEBUG: client disconnected before response completed: %v", err)
			return
		}
		// Error socket yang tidak expected — log sebagai ERROR
		log.Printf("ERROR: socket error: %v", err)
	}
}

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)
        }
    }
}

// Penanganan broken pipe ala Node.js di Go

// CLI tools — menulis ke stdout yang di-pipe
func writeToStdout(lines []string) {
	for _, line := range lines {
		_, err := fmt.Println(line)
		if err != nil {
			if errors.Is(err, syscall.EPIPE) {
				// Output di-pipe ke proses yang sudah selesai (misal: | head -5)
				// Exit dengan code 0 — ini adalah perilaku yang diharapkan
				os.Exit(0)
			}
			// Error lain — propagate
			log.Fatalf("write error: %v", err)
		}
	}
}

// HTTP server — client disconnect saat streaming response
func streamLargeData(w http.ResponseWriter, r *http.Request) {
	stream := generateLargeDataStream()

	// Client menutup koneksi — berhenti generate data
	ctx := r.Context()
	go func() {
		<-ctx.Done()
		stream.Close()
		log.Printf("DEBUG: client disconnected, stream destroyed")
	}()

	if err := stream.WriteTo(w); err != nil {
		if errors.Is(err, syscall.EPIPE) || errors.Is(err, syscall.ECONNRESET) {
			// Client menutup koneksi — normal untuk streaming
			log.Printf("DEBUG: client disconnected: %v", err)
			return
		}
		// Error lain — propagate
		log.Printf("ERROR: stream error: %v", err)
	}
}

// HTTP server — handle write setelah client disconnect
func handleRequest(w http.ResponseWriter, r *http.Request) {
	// Go menampilkan broken pipe sebagai write error — tidak perlu cek socket dulu
	_, err := w.Write(generateResponse())
	if err != nil {
		if errors.Is(err, syscall.EPIPE) || errors.Is(err, syscall.ECONNRESET) {
			log.Printf("DEBUG: client disconnected: %v", err)
		} else {
			log.Printf("ERROR: response error: %v", err)
		}
	}
}

package main

import (
	"io"
	"log"
	"os"
	"strings"
)

// Memfilter broken pipe dari log error server aplikasi.
// Go tidak punya WSGI server seperti Gunicorn; ini ekuivalen
// logging filter: buang pesan yang menyebut "broken pipe".
type brokenPipeFilter struct {
	inner io.Writer
}

func (f brokenPipeFilter) Write(p []byte) (int, error) {
	if strings.Contains(strings.ToLower(string(p)), "broken pipe") {
		return len(p), nil // buang diam-diam
	}
	return f.inner.Write(p)
}

func main() {
	// Arahkan semua output log lewat filter
	log.SetOutput(brokenPipeFilter{inner: os.Stderr})
}

package main

import (
	"log"
	"os"
	"os/signal"
	"sync/atomic"
	"syscall"
	"time"
)

type GracefulServer struct {
	shutdown       chan struct{}
	inShutdown     atomic.Bool
	activeRequests atomic.Int64
}

// Handle SIGTERM untuk graceful shutdown
func NewGracefulServer() *GracefulServer {
	s := &GracefulServer{shutdown: make(chan struct{})}

	ch := make(chan os.Signal, 1)
	signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT)
	go func() {
		<-ch
		s.startShutdown()
	}()

	return s
}

func (s *GracefulServer) startShutdown() {
	// Mulai graceful shutdown saat menerima SIGTERM
	log.Println("Received shutdown signal, starting graceful shutdown...")
	s.inShutdown.Store(true)
	close(s.shutdown)
}

// Handle satu request dengan tracking untuk graceful shutdown
func (s *GracefulServer) handleRequest(request Request) Response {
	if s.inShutdown.Load() {
		// Tolak request baru saat shutdown
		return Response{Status: 503, Body: "Service shutting down"}
	}
	s.activeRequests.Add(1)
	defer s.activeRequests.Add(-1)

	return processRequest(request)
}

// Tunggu semua request selesai sebelum exit.
// Mencegah broken pipe ke client yang sedang aktif.
func (s *GracefulServer) waitForShutdown(timeout time.Duration) {
	<-s.shutdown // tunggu shutdown signal

	deadline := time.Now().Add(timeout)
	for time.Now().Before(deadline) {
		if s.activeRequests.Load() == 0 {
			break
		}
		log.Printf("Waiting for %d active requests...", s.activeRequests.Load())
		time.Sleep(500 * time.Millisecond)
	}

	if s.activeRequests.Load() > 0 {
		log.Printf("Shutdown timeout: %d requests still active", s.activeRequests.Load())
	}
	log.Println("Server shutdown complete")
}

package main

import (
	"errors"
	"fmt"
	"log"
	"os"
	"os/signal"
	"syscall"
)

// ✗ Anti-pattern 1: Log broken pipe sebagai ERROR
// Mengakibatkan ribuan false positive di log dan alert yang tidak perlu
func antiPattern1(err error) {
	log.Printf("ERROR: Broken pipe error: %v", err) // JANGAN untuk client disconnect
}

// ✓ Solusi: log sebagai DEBUG untuk client disconnect yang expected
func solution1(err error) {
	log.Printf("DEBUG: Client disconnected (EPIPE) - normal behavior: %v", err)
}

// ✗ Anti-pattern 2: Tidak handle SIGPIPE, biarkan proses crash
// CLI tool tanpa signal handling crash saat output di-pipe ke | head
func generateReport() {
	for _, line := range hugeDataset {
		_, err := fmt.Println(line)
		if err != nil {
			log.Fatal(err) // crash dengan SIGPIPE jika | head -10 digunakan
		}
	}
}

// ✓ Solusi: handle broken pipe di CLI tools
func generateReportFixed() {
	for _, line := range hugeDataset {
		_, err := fmt.Println(line)
		if err != nil {
			if errors.Is(err, syscall.EPIPE) {
				os.Exit(0)
			}
			log.Fatal(err)
		}
	}
}

// ✗ Anti-pattern 3: Ignore SIGPIPE secara global tanpa pertimbangan
// signal.Ignore(syscall.SIGPIPE) 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
func ignoreSigpipe() {
	signal.Ignore(syscall.SIGPIPE)
	// 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)