Errors

You can define errors in protos and generate enums with protoc-gen-go.

Error in errors pacakge implements GRPCStatus() interface,The conversion between grpc and HTTP error code is realized, and the business reason is returned through errorinfo.

  1. {
  2.     // The error code is consistent with HTTP status and can be converted into grpc status in grpc.
  3.     "code": 500,
  4.     // The error reason is defined as the business judgment error code.
  5.     "reason": "USER_NOT_FOUND",
  6.     // Error information is user-readable information and can be used as user prompt content.
  7.     "message": "invalid argument error",
  8.     // Error meta information, add additional extensible information for the error.
  9.     "metadata": {
  10.       "foo": "bar"
  11.     }
  12. }

Installation

  1. go install github.com/go-kratos/kratos/cmd/protoc-gen-go-errors/v2

Error Defination

api/helloworld/v1/helloworld.proto

  1. syntax = "proto3";
  3. package api.kratos.v1;
  4. import "errors/errors.proto";
  6. // Define the package name for source code reference.
  7. option go_package = "kratos/api/helloworld;helloworld";
  8. option java_multiple_files = true;
  9. option java_package = "api.helloworld";
  11. enum ErrorReason {
  12.   // Set default error code.
  13.   option (errors.default_code) = 500;
  15.   // Set the error code separately for an enumeration.
  16.   USER_NOT_FOUND = 0 [(errors.code) = 404];
  18.   CONTENT_MISSING = 1 [(errors.code) = 400];
  19. }

Error Generation

To generate code with protoc.

  1. protoc --proto_path=. \
  2.          --proto_path=./third_party \
  3.          --go_out=paths=source_relative:. \
  4.          --go-errors_out=paths=source_relative:. \
  5.          $(API_PROTO_FILES)

Or use the makefile directive at the root of the project

  1. make errors

After successful execution, will be generated in the api/helloworld directory a go file,The code is as follows.

  1. package helloworld
  3. import (
  4.     fmt "fmt"
  5.     errors "github.com/go-kratos/kratos/v2/errors"
  6. )
  8. // This is a compile-time assertion to ensure that this generated file
  9. // is compatible with the kratos package it is being compiled against.
  10. const _ = errors.SupportPackageIsVersion1
  12. func IsUserNotFound(err error) bool {
  13.     if err == nil {
  14.         return false
  15.     }
  16.     e := errors.FromError(err)
  17.     return e.Reason == ErrorReason_USER_NOT_FOUND.String() && e.Code == 404
  18. }
  20. func ErrorUserNotFound(format string, args ...interface{}) *errors.Error {
  21.     return errors.New(404, ErrorReason_USER_NOT_FOUND.String(), fmt.Sprintf(format, args...))
  22. }
  24. func IsContentMissing(err error) bool {
  25.     if err == nil {
  26.         return false
  27.     }
  28.     e := errors.FromError(err)
  29.     return e.Reason == ErrorReason_CONTENT_MISSING.String() && e.Code == 400
  30. }
  32. func ErrorContentMissing(format string, args ...interface{}) *errors.Error {
  33.     return errors.New(400, ErrorReason_CONTENT_MISSING.String(), fmt.Sprintf(format, args...))
  34. }

Usage

  1. import "kratos/api/helloworld"
  3. err := wrong()
  5. if errors.Is(err,errors.BadRequest("USER_NAME_EMPTY","")) {
  6. // do something
  7. }
  9. e := errors.FromError(err)
  10. if  e.Reason == "USER_NAME_EMPTY" && e.Code == 500 {
  11. // do something
  12. }
  14. if helloworld.IsUserNotFound(err) {
  15. // do something
  16. })