httplog v3

The library supports structured logging compatible with ECS, OTEL, and GCP. You can use schema objects to define how attributes are replaced in your slog.Handler.

Example of creating a concise schema for local development:

// logFormat is a schema that can be used in slog.Handler's ReplaceAttr
logFormat := httplog.SchemaECS.Concise(isLocalhost)

logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
    ReplaceAttr: logFormat.ReplaceAttr,
}))

Install the httplog middleware using Go modules:

go get github.com/go-chi/httplog/v3@latest

The httplog package provides pre-configured Schema instances to ensure your HTTP logs comply with industry standards. You can use these schemas with slog.Handler to automatically map standard log attributes to the specific field names required by different platforms.

Available schemas:

• SchemaECS: Elastic Common Schema (v9.0.0) for Elasticsearch/Elastic Stack.
• SchemaOTEL: OpenTelemetry semantic conventions (v1.34.0).
• SchemaGCP: Google Cloud Platform structured logging format.

To use a schema, pass its ReplaceAttr method to an slog.Handler (such as slog.NewJSONHandler).

// Example: Using the GCP schema with a JSON handler
handler := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
    ReplaceAttr: SchemaGCP.ReplaceAttr,
})
logger := slog.New(handler)

You can inject custom structured log attributes into the request context from within your own middlewares or handlers. These attributes will be included in the final HTTP log entry produced by httplog.

Use httplog.SetAttrs(ctx, ...) to attach slog.Attr values to the context.

r.Use(func(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()

        // Add custom attributes to the context
        httplog.SetAttrs(ctx, slog.String("user", "user1"))

        next.ServeHTTP(w, r.WithContext(ctx))
    })
})

The LogExtraAttrs field in httplog.Options allows you to inject custom metadata into your logs based on the request and response state. This is useful for adding debugging information like curl commands for failed requests.

Warning: Ensure you do not leak sensitive information (like Authorization headers) when implementing this function.

// Log all requests with invalid payload as curl command.
func(req *http.Request, reqBody string, respStatus int) []slog.Attr {
    if respStatus == 400 || respStatus == 422 {
        // Remove sensitive header before generating curl command
        req.Header.Del("Authorization")
        return []slog.Attr{slog.String("curl", httplog.CURL(req, reqBody))}
    }
    return nil
}

Use SetError to attach an error to the request log context. If the provided error is non-nil, it is added to the log attributes using the key error (defined by the ErrorKey constant). This allows you to record failures within your handlers so they are automatically captured in the final request log entry.

err := doSomething()
if err != nil {
	// This attaches the error to the log context
	httplog.SetError(r.Context(), err)
	return err
}

Use SetAttrs to attach structured slog.Attr values to the current request's log context. These attributes will be included in the log entry generated by the httplog middleware for that specific request. This is useful for adding request-specific metadata (like user IDs or transaction IDs) that you want to appear in your logs.

// Inside a handler or middleware
httplog.SetAttrs(r.Context(), slog.String("user_id", "123"), slog.Int("attempt", 1))

The Concise method returns a simplified version of a schema. When concise is set to true, it strips away most request and response metadata, leaving only essential error and body information. This is useful for reducing log verbosity during local development.

Fields retained in concise mode:

• ErrorMessage
• ErrorStackTrace
• RequestHeaders
• RequestBody
• RequestBytesUnread
• ResponseHeaders
• ResponseBody

// Create a simplified GCP schema for local development
localSchema := SchemaGCP.Concise(true)