How to handle errors when using Templ (SSR)

[pidanou]

Hi guys, I was wondering what would be the best approach for using the centralized error handling approach when working with a server that both serves HTML and JSON over HTTP.

My stack is Go+Templ+Echo. The custom error handler works fine on the JSON part as I can do stuff like:

func buildCustomErrorHandler(logsService *services.LogsService) echo.HTTPErrorHandler {
	return func(err error, c echo.Context) {
		customErr, ok := err.(*types.CustomHTTPError)
		if customErr == nil {
			return
		}
		if !ok {
			customErr = &types.CustomHTTPError{
				StatusCode: http.StatusInternalServerError,
				Severity:   "critical",
				Message:    "Unexpected error",
			}
		}
		timestamp := time.Now().Unix()
		err = logsService.AddLog(timestamp, customErr.Err.Error(), customErr.Severity)
		if err != nil {
			fmt.Println(err)
		}
		c.JSON(customErr.StatusCode, map[string]string{"message": customErr.Message})
	}
}

I just catch all the errors after the handlers, either there are no errors and I do nothing, or there is an error, I store it and send a response.

When using Templ, i do:

	if err != nil {
		return render(c, templates.Index("some stuff"))
	}

I don't really care about the error from the render function.

For now if there is a business error, since the render function rarely throws any error, I never log anything.

How should i manage this?

[hexvalid]

The business error is lost at this line:

return render(c, templates.Index("some stuff"))

If rendering succeeds, that returns nil, so Echo has no error to pass to your centralized handler. Return the business error from the route and let the centralized handler log it and choose the HTML or JSON response.

A useful arrangement is to mark your HTML routes with a context value such as c.Set("responseFormat", "html"). In the error handler:

1. Log the original error once.
2. If c.Response().Committed is true, stop: the response can no longer be replaced.
3. Map the error to your public message and HTTP status.
4. For HTML routes, render an error component with that status; for API routes, call c.JSON.

Buffer the templ output before committing the response, so a rendering failure does not send partial HTML with a successful status:

func renderHTML(c echo.Context, status int, component templ.Component) error {
    var buf bytes.Buffer
    if err := component.Render(c.Request().Context(), &buf); err != nil {
        return err
    }
    return c.HTMLBlob(status, buf.Bytes())
}

This uses bytes and github.com/a-h/templ. Check the returned error in your HTML branch, log it, and use a simple fallback response if the error component itself fails. Avoid recursively calling the same error handler on that rendering failure.

There are also two issues in the handler you posted:

• The customErr == nil return runs before !ok, so ordinary errors are discarded before reaching your 500 fallback. Check the assertion result first, or use errors.As to support wrapped custom errors.
• Your fallback does not populate customErr.Err, so calling customErr.Err.Error() would panic. Keep and log the original error instead.

I checked the error flow with Echo v4.15.4 and templ v0.3.1020: returned errors reached the centralized handler for both response formats, and a failed buffered render left the response uncommitted. References: Echo error handling and templ components.