Method Init

pkg/zen/session.go:55–119

(w http.ResponseWriter, r *http.Request, maxBodySize int64)

}

func (s *Session) Init(w http.ResponseWriter, r *http.Request, maxBodySize int64) error {
	s.requestID = uid.New(uid.RequestPrefix)

	// Wrap ResponseWriter with status recorder
	s.w = &statusRecorder{
		ResponseWriter: w,
		statusCode:     0, // Default to 0, this should always be overwritten by the metrics middleware
		written:        false,
	}

	s.r = r
	s.logRequestToClickHouse = true // Default to logging requests to ClickHouse

	// Apply body size limit if configured
	// Note: MaxBytesReader needs the original unwrapped ResponseWriter, so we pass w directly
	if maxBodySize > 0 {
		s.r.Body = http.MaxBytesReader(w, s.r.Body, maxBodySize)
	}

	// For gRPC/streaming requests, skip body buffering — the body is a stream
	// that must be forwarded incrementally. Buffering would deadlock because the
	// client waits for a response before sending more frames.
	if IsStreamingContentType(r.Header.Get("Content-Type")) {
		s.requestBody = nil
	} else {
		// Read and cache the request body so metrics middleware can access it even on early errors.
		// We need to replace r.Body with a fresh reader afterwards so other middleware
		// can still read the body if necessary.
		var err error
		s.requestBody, err = io.ReadAll(s.r.Body)
		closeErr := s.r.Body.Close()

		// Handle read errors (including MaxBytesError)
		if err != nil {
			// Check if this is a MaxBytesError from http.MaxBytesReader
			var maxBytesErr *http.MaxBytesError
			if errors.As(err, &maxBytesErr) {
				return fault.Wrap(err,
					fault.Code(codes.User.BadRequest.RequestBodyTooLarge.URN()),
					fault.Internal(fmt.Sprintf("request body exceeds size limit of %d bytes", maxBytesErr.Limit)),
					fault.Public(fmt.Sprintf("The request body exceeds the maximum allowed size of %d bytes.", maxBytesErr.Limit)),
				)
			}

			return fault.Wrap(err,
				fault.Code(codes.User.BadRequest.RequestBodyUnreadable.URN()),
				fault.Internal("unable to read request body"),
				fault.Public("The request body could not be read."),
			)
		}

		// Handle close error (incase that ever happens)
		if closeErr != nil {
			return fault.Wrap(closeErr,
				fault.Internal("failed to close request body"),
				fault.Public("An error occurred processing the request."),
			)
		}