Client interceptor

Interface implementation

• To add an interceptor, you need to implement the following functionality

• Then viaclient.AddInterceptorregister the interceptor; afterwards when the service starts it will call the corresponding interceptor through configuration

// ClientInterceptor defines the interface for a client-side interceptor.
// Implementing this allows a module to provide metadata and the actual interceptor logic.
type ClientInterceptor interface {
	// Name returns the unique identifier of the interceptor.
	Name() string
	// Interceptor returns the functional UnaryClientInterceptor.
	Interceptor() UnaryClientInterceptor
}

// UnaryClientInterceptor is a function that intercepts a unary RPC call.
// It can perform logic before and after the invoker is called, such as logging,
// tracing, or modifying request metadata.
type UnaryClientInterceptor func(ctx context.Context, method string, req, reply any, cc ClientConnInterface, invoker UnaryInvoker) error

Supported implementations

• Circuit breaking and graceful degradation

• Loop call detection

• Request error log

• HTTP request headers to GRPC context

• Slow log

• Request parameter validation

• panic log

Configuration

asjard:
  ## client configurations
  clients:
    ## Global protocol-agnostic common interceptors
    # interceptors: ""
    ## Global built-in default interceptors
    # builtInInterceptors: panic,rest2RpcContext,validate,errLog,slowLog,cycleChainInterceptor
    ## Protocol-specific configuration
    grpc:
      ## grpc interceptors
      # interceptors: ""

Update default interceptors:

asjard:
  ## client configurations
  clients:
    ## Global protocol-agnostic common interceptors
    # interceptors: ""
    ## Global built-in default interceptors
    ## Local update syntax
    ## -errLog remove the errLog interceptor
    ## +errLog:customeLog add customeLog interceptor before errLog
    ## errLog+:customeLog add customeLog interceptor after errLog
    ## =errLog:customeLog replace errLog interceptor with customeLog
    ## customeLog append customeLog interceptor to the end of the default interceptors
    # builtInInterceptors: -errLog,customeLog

Custom implementation

package interceptors

import (
	"context"
	"runtime/debug"

	"github.com/asjard/asjard/core/client"
	"github.com/asjard/asjard/core/logger"
	"github.com/asjard/asjard/core/status"
)

const (
	// PanicInterceptorName is the unique identifier for this interceptor.
	PanicInterceptorName = "panic"
)

func init() {
	// Register the panic recovery interceptor globally for all server protocols.
	client.AddInterceptor(PanicInterceptorName, NewPanic)
}

// Panic represents the recovery interceptor component.
type Panic struct{}

// NewPanic initializes the panic interceptor.
func NewPanic() (client.ClientInterceptor, error) {
	return &Panic{}, nil
}

// Interceptor returns the middleware function that handles panic recovery.
func (*Panic) Interceptor() client.UnaryClientInterceptor {
	return func(ctx context.Context, method string, req, reply any, cc client.ClientConnInterface, invoker client.UnaryInvoker) (err error) {
		// Use defer to ensure the recovery logic runs even if the handler panics.
		defer func() {
			if rcv := recover(); rcv != nil {
				// 1. Collect diagnostic information about the crash.
				args := []any{
					"err", rcv, // The actual panic object/message.
					"req", req, // The request payload that triggered the panic.
					"method", method, // The endpoint being called.
					"protocol", cc.Protocol(), // gRPC or REST.
					"service", cc.ServiceName(),
					"stack", string(debug.Stack()), // The full goroutine stack trace.
				}

				// 2. Log the incident with Error level for alerting and debugging.
				logger.L(ctx).Error("request panic", args...)

				// 3. Mask the internal crash from the client by returning a
				// standardized 500 Internal Server Error.
				err = status.InternalServerError()
			}
		}()

		// Execute the next interceptor or the final business logic handler.
		return invoker(ctx, method, req, reply, cc)
	}
}

// Name returns the interceptor's unique name.
func (*Panic) Name() string {
	return PanicInterceptorName
}