Broken Pipe #

package main

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

// Approach 1: Ignore SIGPIPE (common for CLI tools)
// Prevents process termination when the pipe is closed by the reader
func ignoreSigpipe() {
	signal.Ignore(syscall.SIGPIPE)
}

// Approach 2: Handle broken pipes explicitly
func safeWrite(data string) {
	_, err := fmt.Println(data)
	if err != nil {
		if errors.Is(err, syscall.EPIPE) {
			// The reader already closed the pipe — this is OK for CLI tools
			// Exit with the appropriate code
			os.Exit(0)
		}
		log.Fatalf("write error: %v", err)
	}
}

// Approach 3: For scripts with large piped output
// This is the most robust pattern for CLI tools
func main() {
	for item := range generateLargeOutput() {
		fmt.Println(item)
	}
}

// Handling client disconnects when sending a 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) {
			// The client closed the connection before the response finished sending
			// This is normal — log at DEBUG level, not ERROR
			log.Printf("DEBUG: client disconnected before response completed: %v", err)
			return
		}
		// Unexpected socket errors — log as ERROR
		log.Printf("ERROR: socket error: %v", err)
	}
}

package main

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

// Check whether an error is a broken pipe
func isBrokenPipe(err error) bool {
    if err == nil {
        return false
    }
    // Check the various broken pipe error forms in Go
    if errors.Is(err, syscall.EPIPE) {
        return true
    }
    if errors.Is(err, io.ErrClosedPipe) {
        return true
    }
    // For network errors
    var netErr *net.OpError
    if errors.As(err, &netErr) {
        if errors.Is(netErr.Err, syscall.EPIPE) {
            return true
        }
    }
    return false
}

// An HTTP handler handling client disconnects
func handleRequest(w http.ResponseWriter, r *http.Request) {
    data := generateLargeResponse()

    _, err := w.Write(data)
    if err != nil {
        if isBrokenPipe(err) {
            // Client disconnect — log debug only
            log.Printf("DEBUG: client disconnected: %v", err)
            return
        }
        // Other errors worth attention
        log.Printf("ERROR: write failed: %v", err)
    }
}

// Writing to stdout with broken pipe handling
// (for CLI tools whose output gets piped)
func writeToStdout(lines []string) {
    for _, line := range lines {
        _, err := fmt.Println(line)
        if err != nil {
            if isBrokenPipe(err) {
                // The reader closed the pipe — exit normally
                os.Exit(0)
            }
            log.Fatalf("Write error: %v", err)
        }
    }
}

// Node.js-style broken pipe handling in Go

// CLI tools — writing to stdout that gets piped
func writeToStdout(lines []string) {
	for _, line := range lines {
		_, err := fmt.Println(line)
		if err != nil {
			if errors.Is(err, syscall.EPIPE) {
				// Output piped to a process that already finished (e.g. | head -5)
				// Exit with code 0 — this is expected behavior
				os.Exit(0)
			}
			// Other errors — propagate
			log.Fatalf("write error: %v", err)
		}
	}
}

// HTTP server — client disconnects while streaming responses
func streamLargeData(w http.ResponseWriter, r *http.Request) {
	stream := generateLargeDataStream()

	// The client closed the connection — stop generating 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) {
			// The client closed the connection — expected for streaming
			log.Printf("DEBUG: client disconnected: %v", err)
			return
		}
		// Other errors — propagate
		log.Printf("ERROR: stream error: %v", err)
	}
}

// HTTP server — handling writes after client disconnects
func handleRequest(w http.ResponseWriter, r *http.Request) {
	// Go surfaces broken pipes as write errors — no pre-check of the socket needed
	_, 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"
)

// Filtering broken pipes from the app server error log.
// Go has no WSGI server like Gunicorn; this is the equivalent
// of a logging filter: drop messages mentioning "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 // silently drop
	}
	return f.inner.Write(p)
}

func main() {
	// Route all log output through the 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 for graceful shutdowns
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() {
	// Start a graceful shutdown when receiving SIGTERM
	log.Println("Received shutdown signal, starting graceful shutdown...")
	s.inShutdown.Store(true)
	close(s.shutdown)
}

// Handle one request with tracking for graceful shutdowns
func (s *GracefulServer) handleRequest(request Request) Response {
	if s.inShutdown.Load() {
		// Reject new requests during shutdown
		return Response{Status: 503, Body: "Service shutting down"}
	}
	s.activeRequests.Add(1)
	defer s.activeRequests.Add(-1)

	return processRequest(request)
}

// Wait for all requests to finish before exiting.
// Prevents broken pipes to active clients.
func (s *GracefulServer) waitForShutdown(timeout time.Duration) {
	<-s.shutdown // wait for the 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: logging broken pipes as ERROR
// Creates thousands of false positives in logs and unnecessary alerts
func antiPattern1(err error) {
	log.Printf("ERROR: Broken pipe error: %v", err) // DON'T for client disconnects
}

// ✓ Solution: log as DEBUG for expected client disconnects
func solution1(err error) {
	log.Printf("DEBUG: Client disconnected (EPIPE) - normal behavior: %v", err)
}

// ✗ Anti-pattern 2: not handling SIGPIPE, letting processes crash
// CLI tools without signal handling crash when output is piped to | head
func generateReport() {
	for _, line := range hugeDataset {
		_, err := fmt.Println(line)
		if err != nil {
			log.Fatal(err) // crashes with SIGPIPE if | head -10 is used
		}
	}
}

// ✓ Solution: handle broken pipes in 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: globally ignoring SIGPIPE without consideration
// signal.Ignore(syscall.SIGPIPE) in all code
// Can keep processes running endlessly when nobody is reading
// and writing loops without stop into /dev/null

// ✓ Solution: explicitly handle EPIPE after SIG_IGN
func ignoreSigpipe() {
	signal.Ignore(syscall.SIGPIPE)
	// Now you MUST check write() return values and errno
}

// ✗ Anti-pattern 4: no graceful shutdowns
// Pods killed immediately → all active requests get broken pipes
// ✓ Solution: terminationGracePeriodSeconds + preStop hooks in Kubernetes

// ✗ Anti-pattern 5: alerting on-call for every broken pipe
// Broken pipes from client disconnects can number thousands per day in healthy apps
// ✓ Solution: distinguish "broken pipes from client disconnects" (normal)
//   from "broken pipes from internal bugs" (needs alerts)