> ## Documentation Index
> Fetch the complete documentation index at: https://docs.go-mizu.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Request Size

> Request size tracking middleware for monitoring and metrics.

## Overview

The `requestsize` middleware tracks request sizes for monitoring, logging, and metrics collection.

Use it when you need:

* Monitor request sizes
* Collect bandwidth metrics
* Analyze traffic patterns

## Installation

```go theme={null}
import "github.com/go-mizu/mizu/middlewares/requestsize"
```

## Quick Start

```go theme={null}
app := mizu.New()

app.Use(requestsize.New())

app.Post("/upload", func(c *mizu.Ctx) error {
    size := requestsize.Get(c)
    log.Printf("Request size: %d bytes", size)
    return c.Text(200, "OK")
})
```

## Configuration

### Options

| Option | Type | Default | Description |
| - | - | - | - |
| `Handler` | `func(*mizu.Ctx, int64)` | `nil` | Size callback |

## Examples

### Track in Context

```go theme={null}
app.Use(requestsize.New())

app.Post("/api", func(c *mizu.Ctx) error {
    size := requestsize.Get(c)
    // Use size for logging, metrics, etc.
    return c.JSON(200, map[string]int64{"received": size})
})
```

### With Callback

```go theme={null}
app.Use(requestsize.WithHandler(func(c *mizu.Ctx, size int64) {
    metrics.RecordRequestSize(c.Request().URL.Path, size)
}))
```

### Combined with Response Size

```go theme={null}
app.Use(requestsize.New())
app.Use(responsesize.New())

app.Post("/api", func(c *mizu.Ctx) error {
    reqSize := requestsize.Get(c)
    // Response size available after response
    return c.JSON(200, data)
})
```

## API Reference

### Functions

```go theme={null}
// New creates request size middleware
func New() mizu.Middleware

// WithHandler creates with callback
func WithHandler(handler func(*mizu.Ctx, int64)) mizu.Middleware

// Get returns request size from context
func Get(c *mizu.Ctx) int64
```

## Technical Details

The requestsize middleware tracks request sizes by wrapping the request body with a custom `io.ReadCloser` implementation:

### Architecture

* **Context Storage**: Size information is stored in the request context using a private context key
* **Body Wrapping**: The middleware wraps `http.Request.Body` with a `trackingBody` struct that counts bytes as they're read
* **Deferred Callback**: Size callbacks are executed via `defer` to ensure they run after the request body is processed

### Implementation Details

1. **Info Structure**: Contains two fields:
   * `ContentLength`: The `Content-Length` header value (may be -1 if not set)
   * `BytesRead`: Actual bytes read from the request body during processing

2. **Tracking Mechanism**: The `trackingBody` wrapper intercepts all `Read()` calls and accumulates the byte count

3. **Context Integration**: Size info is attached to the request context and can be retrieved using the `Get()`, `ContentLength()`, or `BytesRead()` helper functions

4. **Callback Execution**: If configured, the `OnSize` callback is invoked after request processing completes, providing access to final byte counts

## Best Practices

* Use for bandwidth monitoring
* Track alongside response sizes
* Set alerts for unusually large requests
* Combine with body limit for enforcement

## Testing

The middleware includes comprehensive test coverage for various scenarios:

| Test Case | Description | Expected Behavior |
| - | - | - |
| `TestNew` | Basic middleware initialization and usage | Correctly captures Content-Length header (9 bytes) |
| `TestWithOptions_Callback` | Callback function invocation with options | Callback is called with accurate BytesRead count (5 bytes) |
| `TestContentLength` | ContentLength helper function | Returns correct Content-Length value from context (12 bytes for "test content") |
| `TestBytesRead` | BytesRead tracking for partial reads | Accurately tracks partial body reads (3 bytes out of "hello world") |
| `TestWithCallback` | WithCallback convenience function | Callback is invoked during request processing |
| `TestNoBody` | Requests without body (GET requests) | Handles nil body gracefully with 0 content length |

## Related Middlewares

* [responsesize](/middlewares/responsesize) - Response size tracking
* [bodylimit](/middlewares/bodylimit) - Size enforcement
* [metrics](/middlewares/metrics) - Metrics collection


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.