gen: Error handler is bypassed when using convenient error feature

[danilvpetrov]

TL;DR

Not sure if it is a bug or intended behaviour. When convenient errors are enabled and used, the error handler is not called when an endpoint's handler implementation returns an error.

What version of ogen are you using?

$ go list -m github.com/ogen-go/ogen
github.com/ogen-go/ogen v0.81.0

Can this issue be reproduced with the latest version?

Yes

What did you do?

1. Created a temp directory, ran go mod init example.com/test/test in it.
2. Created a file api.yml with the following content:

openapi: 3.0.2
servers:
  - url: /v3
info:
  version: 1.0.0
  title: Pet store schema
tags:
  - name: pet
    description: Everything about your Pets
paths:
  /pets:
    get:
      tags:
        - pets
      summary: Get all pets
      description: Returns all pets
      operationId: getPets
      responses:
        '200':
          description: successful operation
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Pet'
        default:
          description: unexpected error
          content:
            application/json:
              schema:
                type: object
                required:
                  - error_message
                properties:
                  error_message:
                    description: A description of the error
                    type: string

components:
  schemas:
    Pet:
      type: object
      required:
        - name
      properties:
        id:
          type: integer
          format: int64
          example: 10
        name:
          type: string
          example: doggie
        photoUrls:
          type: array
          items:
            type: string

3. Ran the following command to generate code: ogen --target gen --package gen --clean api.yml in the temporary directory.
4. Created a main.go file in the temporary directory with the following content:

package main

import (
	"context"
	"errors"
	"fmt"
	"net/http"

	"example.com/test/test/gen"
)

type handler struct{}

func (h *handler) GetPets(_ context.Context) ([]gen.Pet, error) {
	return nil, errors.New("get pets error")
}

func (h *handler) NewError(_ context.Context, err error) *gen.ErrRespStatusCode {
	return &gen.ErrRespStatusCode{
		StatusCode: http.StatusInternalServerError,
		Response: gen.ErrResp{
			ErrorMessage: "internal server error",
		},
	}
}

func main() {
	s, err := gen.NewServer(
		&handler{},
		gen.WithErrorHandler(func(
			ctx context.Context,
			w http.ResponseWriter,
			r *http.Request,
			err error,
		) {
			fmt.Printf("trying to log this error: %v\n", err)
		}),
	)
	if err != nil {
		panic(err)
	}

	http.ListenAndServe(":8080", s)
}

5. Ran go run main.go in the temporary directory.
6. Ran curl localhost:8080/pets In a separate terminal window

What did you expect to see?

The expectation was to see a print out trying to log this error: get pets error In the terminal window that was running go run main.go command.

What did you see instead?

No print out of the expected message was seen.