Body Close

​

Overview

• Prevent connection leaks
• Ensure proper resource cleanup
• Handle abandoned requests

​

Installation

import "github.com/go-mizu/mizu/middlewares/bodyclose"

​

Quick Start

app := mizu.New()

// Auto-close request bodies
app.Use(bodyclose.New())

​

Examples

​

Basic Usage

app.Use(bodyclose.New())

​

With Drain

// Drain body before closing (for keep-alive)
app.Use(bodyclose.WithDrain())

​

API Reference

​

Functions

// New creates body close middleware with default options
func New() mizu.Middleware

// WithOptions creates bodyclose middleware with custom options
func WithOptions(opts Options) mizu.Middleware

// Drain creates middleware that drains request bodies
func Drain() mizu.Middleware

// NoDrain creates middleware that closes without draining
func NoDrain() mizu.Middleware

​

Options

type Options struct {
    // DrainBody drains the body before closing.
    // Default: true.
    DrainBody bool

    // MaxDrain is the maximum bytes to drain.
    // Default: 8KB.
    MaxDrain int64
}

​

Technical Details

​

Implementation Strategy

1. Nil Body Check: Immediately passes control to the next handler if the request body is nil, avoiding unnecessary overhead
2. Deferred Cleanup: Uses Go’s defer statement to guarantee body cleanup regardless of handler outcome (success, error, or panic)
3. Optional Draining: When DrainBody is enabled, reads and discards up to MaxDrain bytes before closing to enable HTTP keep-alive connection reuse
4. Connection Reuse: By draining the body, the middleware signals to the HTTP client that the connection can be safely reused in connection pools

​

Resource Management

• Default MaxDrain: 8KB (8192 bytes) to balance connection reuse benefits with performance
• Drain Mechanism: Uses io.CopyN to limit the amount of data drained, preventing excessive memory consumption on large bodies
• Error Handling: Silently ignores drain and close errors to prevent interference with the main request flow

​

Performance Characteristics

• Minimal Overhead: Only adds a single function call and defer statement per request
• Memory Efficient: Draining is capped by MaxDrain to prevent memory exhaustion
• No Blocking: Draining respects the MaxDrain limit and doesn’t attempt to fully read unbounded bodies

​

Why It Matters

• Connections may not be reused
• Memory leaks can occur
• Connection pool exhaustion

​

Best Practices

• Place early in middleware chain
• Use with connection pooling
• Consider draining for HTTP keep-alive

​

Testing

​

Test Coverage

• Whether the body was closed (closed field)
• Whether the body was fully drained (drained field)

​

Related Middlewares

• bodylimit - Limit body size
• bodydump - Dump request bodies
• timeout - Request timeout