diff --git a/client/tso_batch_controller.go b/client/tso_batch_controller.go
index 3ad05ca7cba1..842c772abd96 100644
--- a/client/tso_batch_controller.go
+++ b/client/tso_batch_controller.go
@@ -44,16 +44,16 @@ func newTSOBatchController(tsoRequestCh chan *tsoRequest, maxBatchSize int) *tso
 // fetchPendingRequests will start a new round of the batch collecting from the channel.
 // It returns true if everything goes well, otherwise false which means we should stop the service.
 func (tbc *tsoBatchController) fetchPendingRequests(ctx context.Context, maxBatchWaitInterval time.Duration) error {
-	var firstTSORequest *tsoRequest
+	var firstRequest *tsoRequest
 	select {
 	case <-ctx.Done():
 		return ctx.Err()
-	case firstTSORequest = <-tbc.tsoRequestCh:
+	case firstRequest = <-tbc.tsoRequestCh:
 	}
 	// Start to batch when the first TSO request arrives.
 	tbc.batchStartTime = time.Now()
 	tbc.collectedRequestCount = 0
-	tbc.pushRequest(firstTSORequest)
+	tbc.pushRequest(firstRequest)
 
 	// This loop is for trying best to collect more requests, so we use `tbc.maxBatchSize` here.
 fetchPendingRequestsLoop:
@@ -130,7 +130,7 @@ func (tbc *tsoBatchController) adjustBestBatchSize() {
 	}
 }
 
-func (tbc *tsoBatchController) revokePendingTSORequest(err error) {
+func (tbc *tsoBatchController) revokePendingRequest(err error) {
 	for i := 0; i < len(tbc.tsoRequestCh); i++ {
 		req := <-tbc.tsoRequestCh
 		req.done <- err
diff --git a/client/tso_client.go b/client/tso_client.go
index c5427af9dc30..a13d635b986f 100644
--- a/client/tso_client.go
+++ b/client/tso_client.go
@@ -141,7 +141,7 @@ func (c *tsoClient) Close() {
 		if dispatcherInterface != nil {
 			dispatcher := dispatcherInterface.(*tsoDispatcher)
 			tsoErr := errors.WithStack(errClosing)
-			dispatcher.tsoBatchController.revokePendingTSORequest(tsoErr)
+			dispatcher.tsoBatchController.revokePendingRequest(tsoErr)
 			dispatcher.dispatcherCancel()
 		}
 		return true
diff --git a/client/tso_dispatcher.go b/client/tso_dispatcher.go
index 7af4c859a3ee..c9c0f47d4d3f 100644
--- a/client/tso_dispatcher.go
+++ b/client/tso_dispatcher.go
@@ -404,7 +404,7 @@ tsoBatchLoop:
 					err = errs.ErrClientCreateTSOStream.FastGenByArgs(errs.RetryTimeoutErr)
 					log.Error("[tso] create tso stream error", zap.String("dc-location", dc), errs.ZapError(err))
 					c.svcDiscovery.ScheduleCheckMemberChanged()
-					c.finishTSORequest(tbc.getCollectedRequests(), 0, 0, 0, errors.WithStack(err))
+					c.finishRequest(tbc.getCollectedRequests(), 0, 0, 0, errors.WithStack(err))
 					continue tsoBatchLoop
 				case <-time.After(retryInterval):
 					continue streamChoosingLoop
@@ -440,7 +440,7 @@ tsoBatchLoop:
 		case tsDeadlineCh.(chan deadline) <- dl:
 		}
 		opts = extractSpanReference(tbc, opts[:0])
-		err = c.processTSORequests(stream, dc, tbc, opts)
+		err = c.processRequests(stream, dc, tbc, opts)
 		close(done)
 		// If error happens during tso stream handling, reset stream and run the next trial.
 		if err != nil {
@@ -691,9 +691,9 @@ func extractSpanReference(tbc *tsoBatchController, opts []opentracing.StartSpanO
 	return opts
 }
 
-func (c *tsoClient) processTSORequests(stream tsoStream, dcLocation string, tbc *tsoBatchController, opts []opentracing.StartSpanOption) error {
+func (c *tsoClient) processRequests(stream tsoStream, dcLocation string, tbc *tsoBatchController, opts []opentracing.StartSpanOption) error {
 	if len(opts) > 0 {
-		span := opentracing.StartSpan("pdclient.processTSORequests", opts...)
+		span := opentracing.StartSpan("pdclient.processRequests", opts...)
 		defer span.Finish()
 	}
 
@@ -701,13 +701,13 @@ func (c *tsoClient) processTSORequests(stream tsoStream, dcLocation string, tbc
 	count := int64(len(requests))
 	physical, logical, suffixBits, err := stream.processRequests(c.svcDiscovery.GetClusterID(), dcLocation, requests, tbc.batchStartTime)
 	if err != nil {
-		c.finishTSORequest(requests, 0, 0, 0, err)
+		c.finishRequest(requests, 0, 0, 0, err)
 		return err
 	}
 	// `logical` is the largest ts's logical part here, we need to do the subtracting before we finish each TSO request.
 	firstLogical := addLogical(logical, -count+1, suffixBits)
 	c.compareAndSwapTS(dcLocation, physical, firstLogical, suffixBits, count)
-	c.finishTSORequest(requests, physical, firstLogical, suffixBits, nil)
+	c.finishRequest(requests, physical, firstLogical, suffixBits, nil)
 	return nil
 }
 
@@ -747,7 +747,7 @@ func tsLessEqual(physical, logical, thatPhysical, thatLogical int64) bool {
 	return physical < thatPhysical
 }
 
-func (c *tsoClient) finishTSORequest(requests []*tsoRequest, physical, firstLogical int64, suffixBits uint32, err error) {
+func (c *tsoClient) finishRequest(requests []*tsoRequest, physical, firstLogical int64, suffixBits uint32, err error) {
 	for i := 0; i < len(requests); i++ {
 		if span := opentracing.SpanFromContext(requests[i].requestCtx); span != nil {
 			span.Finish()
diff --git a/pkg/mcs/tso/server/grpc_service.go b/pkg/mcs/tso/server/grpc_service.go
index 504cb8f14439..c5a4059e421d 100644
--- a/pkg/mcs/tso/server/grpc_service.go
+++ b/pkg/mcs/tso/server/grpc_service.go
@@ -118,8 +118,8 @@ func (s *Service) Tso(stream tsopb.TSO_TsoServer) error {
 				errCh = make(chan error)
 			}
 
-			tsoProtoFactory := s.TSOProtoFactory
-			tsoRequest := tsoutil.NewTSOProtoTSORequest(forwardedHost, clientConn, request, stream)
+			tsoProtoFactory := s.tsoProtoFactory
+			tsoRequest := tsoutil.NewTSOProtoRequest(forwardedHost, clientConn, request, stream)
 			s.tsoDispatcher.DispatchRequest(ctx, tsoRequest, tsoProtoFactory, doneCh, errCh)
 			continue
 		}
@@ -133,7 +133,7 @@ func (s *Service) Tso(stream tsopb.TSO_TsoServer) error {
 			return status.Errorf(codes.FailedPrecondition, "mismatch cluster id, need %d but got %d", s.clusterID, request.GetHeader().GetClusterId())
 		}
 		count := request.GetCount()
-		ts, err := s.tsoAllocatorManager.HandleTSORequest(request.GetDcLocation(), count)
+		ts, err := s.tsoAllocatorManager.HandleRequest(request.GetDcLocation(), count)
 		if err != nil {
 			return status.Errorf(codes.Unknown, err.Error())
 		}
diff --git a/pkg/mcs/tso/server/server.go b/pkg/mcs/tso/server/server.go
index ab2a0ac519f4..0c83fc4e2527 100644
--- a/pkg/mcs/tso/server/server.go
+++ b/pkg/mcs/tso/server/server.go
@@ -111,12 +111,12 @@ type Server struct {
 	tsoAllocatorManager *tso.AllocatorManager
 	// Store as map[string]*grpc.ClientConn
 	clientConns sync.Map
-	// tsoDispatcher is used to dispatch different TSO requests to
-	// the corresponding forwarding TSO channel.
+	// tsoDispatcher is used to dispatch the TSO requests to
+	// the corresponding forwarding TSO channels.
 	tsoDispatcher *tsoutil.TSODispatcher
-	// TSOProtoFactory is the abstract factory for creating tso
-	// related data structures defined in pd protocol
-	TSOProtoFactory *tsoutil.TSOProtoFactory
+	// tsoProtoFactory is the abstract factory for creating tso
+	// related data structures defined in the tso grpc protocol
+	tsoProtoFactory *tsoutil.TSOProtoFactory
 
 	// Callback functions for different stages
 	// startCallbacks will be called after the server is started.
@@ -562,7 +562,7 @@ func (s *Server) startServer() (err error) {
 	// Set up the Global TSO Allocator here, it will be initialized once this TSO participant campaigns leader successfully.
 	s.tsoAllocatorManager.SetUpAllocator(s.ctx, tso.GlobalDCLocation, s.participant.GetLeadership())
 	s.tsoDispatcher = tsoutil.NewTSODispatcher(tsoProxyHandleDuration, tsoProxyBatchSize)
-	s.TSOProtoFactory = &tsoutil.TSOProtoFactory{}
+	s.tsoProtoFactory = &tsoutil.TSOProtoFactory{}
 
 	s.service = &Service{Server: s}
 
diff --git a/pkg/tso/allocator_manager.go b/pkg/tso/allocator_manager.go
index a3de87311bb8..2a5fed634941 100644
--- a/pkg/tso/allocator_manager.go
+++ b/pkg/tso/allocator_manager.go
@@ -983,8 +983,8 @@ func (am *AllocatorManager) deleteAllocatorGroup(dcLocation string) {
 	}
 }
 
-// HandleTSORequest forwards TSO allocation requests to correct TSO Allocators.
-func (am *AllocatorManager) HandleTSORequest(dcLocation string, count uint32) (pdpb.Timestamp, error) {
+// HandleRequest forwards TSO allocation requests to correct TSO Allocators.
+func (am *AllocatorManager) HandleRequest(dcLocation string, count uint32) (pdpb.Timestamp, error) {
 	if dcLocation == "" {
 		dcLocation = GlobalDCLocation
 	}
diff --git a/pkg/utils/tsoutil/tso_dispatcher.go b/pkg/utils/tsoutil/tso_dispatcher.go
index 7f91d945ee05..26e24e119995 100644
--- a/pkg/utils/tsoutil/tso_dispatcher.go
+++ b/pkg/utils/tsoutil/tso_dispatcher.go
@@ -28,7 +28,7 @@ import (
 )
 
 const (
-	maxMergeTSORequests = 10000
+	maxMergeRequests = 10000
 	// DefaultTSOProxyTimeout defines the default timeout value of TSP Proxying
 	DefaultTSOProxyTimeout = 3 * time.Second
 )
@@ -37,13 +37,13 @@ type tsoResp interface {
 	GetTimestamp() *pdpb.Timestamp
 }
 
-// TSODispatcher is used to dispatch different TSO requests to the corresponding forwarding TSO channel.
+// TSODispatcher dispatches the TSO requests to the corresponding forwarding TSO channels.
 type TSODispatcher struct {
 	tsoProxyHandleDuration prometheus.Histogram
 	tsoProxyBatchSize      prometheus.Histogram
 
-	// dispatchChs is used to dispatch different TSO requests to the corresponding forwarding TSO channel.
-	dispatchChs sync.Map // Store as map[string]chan TSORequest
+	// dispatchChs is used to dispatch different TSO requests to the corresponding forwarding TSO channels.
+	dispatchChs sync.Map // Store as map[string]chan Request
 }
 
 // NewTSODispatcher creates and returns a TSODispatcher
@@ -56,18 +56,21 @@ func NewTSODispatcher(tsoProxyHandleDuration, tsoProxyBatchSize prometheus.Histo
 }
 
 // DispatchRequest is the entry point for dispatching/forwarding a tso request to the detination host
-func (s *TSODispatcher) DispatchRequest(ctx context.Context, req TSORequest, tsoProtoFactory ProtoFactory, doneCh <-chan struct{}, errCh chan<- error) {
-	tsoRequestChInterface, loaded := s.dispatchChs.LoadOrStore(req.getForwardedHost(), make(chan TSORequest, maxMergeTSORequests))
+func (s *TSODispatcher) DispatchRequest(
+	ctx context.Context, req Request, tsoProtoFactory ProtoFactory, doneCh <-chan struct{}, errCh chan<- error) {
+	val, loaded := s.dispatchChs.LoadOrStore(req.getForwardedHost(), make(chan Request, maxMergeRequests))
+	reqCh := val.(chan Request)
 	if !loaded {
 		tsDeadlineCh := make(chan deadline, 1)
-		go s.handleDispatcher(ctx, tsoProtoFactory, req.getForwardedHost(), req.getClientConn(), tsoRequestChInterface.(chan TSORequest), tsDeadlineCh, doneCh, errCh)
+		go s.dispatch(ctx, tsoProtoFactory, req.getForwardedHost(), req.getClientConn(), reqCh, tsDeadlineCh, doneCh, errCh)
 		go watchTSDeadline(ctx, tsDeadlineCh)
 	}
-	tsoRequestChInterface.(chan TSORequest) <- req
+	reqCh <- req
 }
 
-func (s *TSODispatcher) handleDispatcher(ctx context.Context, tsoProtoFactory ProtoFactory, forwardedHost string, clientConn *grpc.ClientConn,
-	tsoRequestCh <-chan TSORequest, tsDeadlineCh chan<- deadline, doneCh <-chan struct{}, errCh chan<- error) {
+func (s *TSODispatcher) dispatch(
+	ctx context.Context, tsoProtoFactory ProtoFactory, forwardedHost string, clientConn *grpc.ClientConn,
+	tsoRequestCh <-chan Request, tsDeadlineCh chan<- deadline, doneCh <-chan struct{}, errCh chan<- error) {
 	dispatcherCtx, ctxCancel := context.WithCancel(ctx)
 	defer ctxCancel()
 	defer s.dispatchChs.Delete(forwardedHost)
@@ -75,7 +78,9 @@ func (s *TSODispatcher) handleDispatcher(ctx context.Context, tsoProtoFactory Pr
 	log.Info("create tso forward stream", zap.String("forwarded-host", forwardedHost))
 	forwardStream, cancel, err := tsoProtoFactory.createForwardStream(ctx, clientConn)
 	if err != nil || forwardStream == nil {
-		log.Error("create tso forwarding stream error", zap.String("forwarded-host", forwardedHost), errs.ZapError(errs.ErrGRPCCreateStream, err))
+		log.Error("create tso forwarding stream error",
+			zap.String("forwarded-host", forwardedHost),
+			errs.ZapError(errs.ErrGRPCCreateStream, err))
 		select {
 		case <-dispatcherCtx.Done():
 			return
@@ -90,7 +95,7 @@ func (s *TSODispatcher) handleDispatcher(ctx context.Context, tsoProtoFactory Pr
 	}
 	defer cancel()
 
-	requests := make([]TSORequest, maxMergeTSORequests+1)
+	requests := make([]Request, maxMergeRequests+1)
 	for {
 		select {
 		case first := <-tsoRequestCh:
@@ -110,10 +115,12 @@ func (s *TSODispatcher) handleDispatcher(ctx context.Context, tsoProtoFactory Pr
 			case <-dispatcherCtx.Done():
 				return
 			}
-			err = s.processTSORequests(forwardStream, requests[:pendingTSOReqCount], tsoProtoFactory)
+			err = s.processRequests(forwardStream, requests[:pendingTSOReqCount], tsoProtoFactory)
 			close(done)
 			if err != nil {
-				log.Error("proxy forward tso error", zap.String("forwarded-host", forwardedHost), errs.ZapError(errs.ErrGRPCSend, err))
+				log.Error("proxy forward tso error",
+					zap.String("forwarded-host", forwardedHost),
+					errs.ZapError(errs.ErrGRPCSend, err))
 				select {
 				case <-dispatcherCtx.Done():
 					return
@@ -132,7 +139,7 @@ func (s *TSODispatcher) handleDispatcher(ctx context.Context, tsoProtoFactory Pr
 	}
 }
 
-func (s *TSODispatcher) processTSORequests(forwardStream tsoStream, requests []TSORequest, tsoProtoFactory ProtoFactory) error {
+func (s *TSODispatcher) processRequests(forwardStream stream, requests []Request, tsoProtoFactory ProtoFactory) error {
 	start := time.Now()
 	// Merge the requests
 	count := uint32(0)
@@ -146,12 +153,13 @@ func (s *TSODispatcher) processTSORequests(forwardStream tsoStream, requests []T
 	s.tsoProxyHandleDuration.Observe(time.Since(start).Seconds())
 	s.tsoProxyBatchSize.Observe(float64(count))
 	// Split the response
-	physical, logical, suffixBits := resp.GetTimestamp().GetPhysical(), resp.GetTimestamp().GetLogical(), resp.GetTimestamp().GetSuffixBits()
+	ts := resp.GetTimestamp()
+	physical, logical, suffixBits := ts.GetPhysical(), ts.GetLogical(), ts.GetSuffixBits()
 	// `logical` is the largest ts's logical part here, we need to do the subtracting before we finish each TSO request.
 	// This is different from the logic of client batch, for example, if we have a largest ts whose logical part is 10,
 	// count is 5, then the splitting results should be 5 and 10.
 	firstLogical := addLogical(logical, -int64(count), suffixBits)
-	return s.finishTSORequest(requests, physical, firstLogical, suffixBits)
+	return s.finishRequest(requests, physical, firstLogical, suffixBits)
 }
 
 // Because of the suffix, we need to shift the count before we add it to the logical part.
@@ -159,7 +167,7 @@ func addLogical(logical, count int64, suffixBits uint32) int64 {
 	return logical + count<<suffixBits
 }
 
-func (s *TSODispatcher) finishTSORequest(requests []TSORequest, physical, firstLogical int64, suffixBits uint32) error {
+func (s *TSODispatcher) finishRequest(requests []Request, physical, firstLogical int64, suffixBits uint32) error {
 	countSum := int64(0)
 	for i := 0; i < len(requests); i++ {
 		newCountSum, err := requests[i].postProcess(countSum, physical, firstLogical, suffixBits)
@@ -185,7 +193,8 @@ func watchTSDeadline(ctx context.Context, tsDeadlineCh <-chan deadline) {
 		case d := <-tsDeadlineCh:
 			select {
 			case <-d.timer:
-				log.Error("tso proxy request processing is canceled due to timeout", errs.ZapError(errs.ErrProxyTSOTimeout))
+				log.Error("tso proxy request processing is canceled due to timeout",
+					errs.ZapError(errs.ErrProxyTSOTimeout))
 				d.cancel()
 			case <-d.done:
 				continue
diff --git a/pkg/utils/tsoutil/tso_proto_factory.go b/pkg/utils/tsoutil/tso_proto_factory.go
index fb87e7887427..e497457e64ce 100644
--- a/pkg/utils/tsoutil/tso_proto_factory.go
+++ b/pkg/utils/tsoutil/tso_proto_factory.go
@@ -22,60 +22,57 @@ import (
 	"google.golang.org/grpc"
 )
 
-// ProtoFactory is the abstract factory for creating tso related data structures defined in the gPRC service
+// ProtoFactory is the abstract factory for creating tso related data structures defined in the grpc service
 type ProtoFactory interface {
-	createForwardStream(ctx context.Context, client *grpc.ClientConn) (tsoStream, context.CancelFunc, error)
+	createForwardStream(ctx context.Context, client *grpc.ClientConn) (stream, context.CancelFunc, error)
 }
 
-// TSOProtoFactory is the abstract factory for creating tso related data structures defined in the TSO gPRC service
+// TSOProtoFactory is the abstract factory for creating tso related data structures defined in the TSO grpc service
 type TSOProtoFactory struct {
 }
 
-// PDProtoFactory is the abstract factory for creating tso related data structures defined in the PD gPRC service
+// PDProtoFactory is the abstract factory for creating tso related data structures defined in the PD grpc service
 type PDProtoFactory struct {
 }
 
-func (s *TSOProtoFactory) createForwardStream(ctx context.Context, clientConn *grpc.ClientConn) (tsoStream, context.CancelFunc, error) {
+func (s *TSOProtoFactory) createForwardStream(ctx context.Context, clientConn *grpc.ClientConn) (stream, context.CancelFunc, error) {
 	done := make(chan struct{})
 	cctx, cancel := context.WithCancel(ctx)
 	go checkStream(cctx, cancel, done)
 	forwardStream, err := tsopb.NewTSOClient(clientConn).Tso(cctx)
 	done <- struct{}{}
-	return &tsoTSOStream{forwardStream}, cancel, err
+	return &tsoStream{forwardStream}, cancel, err
 }
 
-func (s *PDProtoFactory) createForwardStream(ctx context.Context, clientConn *grpc.ClientConn) (tsoStream, context.CancelFunc, error) {
+func (s *PDProtoFactory) createForwardStream(ctx context.Context, clientConn *grpc.ClientConn) (stream, context.CancelFunc, error) {
 	done := make(chan struct{})
 	cctx, cancel := context.WithCancel(ctx)
 	go checkStream(cctx, cancel, done)
 	forwardStream, err := pdpb.NewPDClient(clientConn).Tso(cctx)
 	done <- struct{}{}
-	return &pdTSOStream{forwardStream}, cancel, err
+	return &pdStream{forwardStream}, cancel, err
 }
 
-type tsoStream interface {
+type stream interface {
 	// process sends a request and receives the response through the stream
-	process(clusterID uint64, count, keyspaceID, keyspaceGroupID uint32, dcLocation string) (tsoResponse, error)
+	process(clusterID uint64, count, keyspaceID, keyspaceGroupID uint32, dcLocation string) (response, error)
 }
 
-type tsoTSOStream struct {
+type tsoStream struct {
 	stream tsopb.TSO_TsoClient
 }
 
 // process sends a request and receives the response through the stream
-func (s *tsoTSOStream) process(clusterID uint64, count, keyspaceID, keyspaceGroupID uint32, dcLocation string) (tsoResponse, error) {
+func (s *tsoStream) process(clusterID uint64, count, keyspaceID, keyspaceGroupID uint32, dcLocation string) (response, error) {
 	req := &tsopb.TsoRequest{
 		Header: &tsopb.RequestHeader{
 			ClusterId:       clusterID,
 			KeyspaceId:      keyspaceID,
 			KeyspaceGroupId: keyspaceGroupID,
 		},
-		Count: count,
-		// TODO: support Local TSO proxy forwarding.
+		Count:      count,
 		DcLocation: dcLocation,
 	}
-
-	// Send to the tso server stream
 	if err := s.stream.Send(req); err != nil {
 		return nil, err
 	}
@@ -86,21 +83,19 @@ func (s *tsoTSOStream) process(clusterID uint64, count, keyspaceID, keyspaceGrou
 	return resp, nil
 }
 
-type pdTSOStream struct {
+type pdStream struct {
 	stream pdpb.PD_TsoClient
 }
 
 // process sends a request and receives the response through the stream
-func (s *pdTSOStream) process(clusterID uint64, count, _, _ uint32, dcLocation string) (tsoResponse, error) {
+func (s *pdStream) process(clusterID uint64, count, _, _ uint32, dcLocation string) (response, error) {
 	req := &pdpb.TsoRequest{
 		Header: &pdpb.RequestHeader{
 			ClusterId: clusterID,
 		},
-		Count: count,
-		// TODO: support Local TSO proxy forwarding.
+		Count:      count,
 		DcLocation: dcLocation,
 	}
-	// Send to the tso server stream
 	if err := s.stream.Send(req); err != nil {
 		return nil, err
 	}
diff --git a/pkg/utils/tsoutil/tso_request.go b/pkg/utils/tsoutil/tso_request.go
index 329f80be4742..b1998e458da6 100644
--- a/pkg/utils/tsoutil/tso_request.go
+++ b/pkg/utils/tsoutil/tso_request.go
@@ -21,9 +21,9 @@ import (
 	"google.golang.org/grpc"
 )
 
-// TSORequest is an interface wrapping tsopb.TsoRequest and pdpb.TsoRequest so
+// Request is an interface wrapping tsopb.TsoRequest and pdpb.TsoRequest so
 // they can be generally handled by the TSO dispatcher
-type TSORequest interface {
+type Request interface {
 	// getForwardedHost returns the forwarded host
 	getForwardedHost() string
 	// getClientConn returns the grpc client connection
@@ -32,26 +32,27 @@ type TSORequest interface {
 	getCount() uint32
 	// process sends request and receive response via stream.
 	// count defins the count of timestamps to retrieve.
-	process(forwardStream tsoStream, count uint32, tsoProtoFactory ProtoFactory) (tsoResp, error)
+	process(forwardStream stream, count uint32, tsoProtoFactory ProtoFactory) (tsoResp, error)
 	// postProcess sends the response back to the sender of the request
 	postProcess(countSum, physical, firstLogical int64, suffixBits uint32) (int64, error)
 }
 
-type tsoResponse interface {
+// response is an interface wrapping tsopb.TsoResponse and pdpb.TsoResponse
+type response interface {
 	GetTimestamp() *pdpb.Timestamp
 }
 
-// TSOProtoTSORequest wraps the request and stream channel in the TSO grpc service
-type TSOProtoTSORequest struct {
+// TSOProtoRequest wraps the request and stream channel in the TSO grpc service
+type TSOProtoRequest struct {
 	forwardedHost string
 	clientConn    *grpc.ClientConn
 	request       *tsopb.TsoRequest
 	stream        tsopb.TSO_TsoServer
 }
 
-// NewTSOProtoTSORequest creats a TSOProtoTSORequest and returns as a TSORequest
-func NewTSOProtoTSORequest(forwardedHost string, clientConn *grpc.ClientConn, request *tsopb.TsoRequest, stream tsopb.TSO_TsoServer) TSORequest {
-	tsoRequest := &TSOProtoTSORequest{
+// NewTSOProtoRequest creats a TSOProtoRequest and returns as a Request
+func NewTSOProtoRequest(forwardedHost string, clientConn *grpc.ClientConn, request *tsopb.TsoRequest, stream tsopb.TSO_TsoServer) Request {
+	tsoRequest := &TSOProtoRequest{
 		forwardedHost: forwardedHost,
 		clientConn:    clientConn,
 		request:       request,
@@ -61,29 +62,29 @@ func NewTSOProtoTSORequest(forwardedHost string, clientConn *grpc.ClientConn, re
 }
 
 // getForwardedHost returns the forwarded host
-func (r *TSOProtoTSORequest) getForwardedHost() string {
+func (r *TSOProtoRequest) getForwardedHost() string {
 	return r.forwardedHost
 }
 
 // getClientConn returns the grpc client connection
-func (r *TSOProtoTSORequest) getClientConn() *grpc.ClientConn {
+func (r *TSOProtoRequest) getClientConn() *grpc.ClientConn {
 	return r.clientConn
 }
 
 // getCount returns the count of timestamps to retrieve
-func (r *TSOProtoTSORequest) getCount() uint32 {
+func (r *TSOProtoRequest) getCount() uint32 {
 	return r.request.GetCount()
 }
 
 // process sends request and receive response via stream.
 // count defins the count of timestamps to retrieve.
-func (r *TSOProtoTSORequest) process(forwardStream tsoStream, count uint32, tsoProtoFactory ProtoFactory) (tsoResp, error) {
+func (r *TSOProtoRequest) process(forwardStream stream, count uint32, tsoProtoFactory ProtoFactory) (tsoResp, error) {
 	return forwardStream.process(r.request.GetHeader().GetClusterId(), count,
 		r.request.GetHeader().GetKeyspaceId(), r.request.GetHeader().GetKeyspaceGroupId(), r.request.GetDcLocation())
 }
 
 // postProcess sends the response back to the sender of the request
-func (r *TSOProtoTSORequest) postProcess(countSum, physical, firstLogical int64, suffixBits uint32) (int64, error) {
+func (r *TSOProtoRequest) postProcess(countSum, physical, firstLogical int64, suffixBits uint32) (int64, error) {
 	count := r.request.GetCount()
 	countSum += int64(count)
 	response := &tsopb.TsoResponse{
@@ -102,17 +103,17 @@ func (r *TSOProtoTSORequest) postProcess(countSum, physical, firstLogical int64,
 	return countSum, nil
 }
 
-// PDProtoTSORequest wraps the request and stream channel in the PD grpc service
-type PDProtoTSORequest struct {
+// PDProtoRequest wraps the request and stream channel in the PD grpc service
+type PDProtoRequest struct {
 	forwardedHost string
 	clientConn    *grpc.ClientConn
 	request       *pdpb.TsoRequest
 	stream        pdpb.PD_TsoServer
 }
 
-// NewPDProtoTSORequest creats a PDProtoTSORequest and returns as a TSORequest
-func NewPDProtoTSORequest(forwardedHost string, clientConn *grpc.ClientConn, request *pdpb.TsoRequest, stream pdpb.PD_TsoServer) TSORequest {
-	tsoRequest := &PDProtoTSORequest{
+// NewPDProtoRequest creats a PDProtoRequest and returns as a Request
+func NewPDProtoRequest(forwardedHost string, clientConn *grpc.ClientConn, request *pdpb.TsoRequest, stream pdpb.PD_TsoServer) Request {
+	tsoRequest := &PDProtoRequest{
 		forwardedHost: forwardedHost,
 		clientConn:    clientConn,
 		request:       request,
@@ -122,29 +123,29 @@ func NewPDProtoTSORequest(forwardedHost string, clientConn *grpc.ClientConn, req
 }
 
 // getForwardedHost returns the forwarded host
-func (r *PDProtoTSORequest) getForwardedHost() string {
+func (r *PDProtoRequest) getForwardedHost() string {
 	return r.forwardedHost
 }
 
 // getClientConn returns the grpc client connection
-func (r *PDProtoTSORequest) getClientConn() *grpc.ClientConn {
+func (r *PDProtoRequest) getClientConn() *grpc.ClientConn {
 	return r.clientConn
 }
 
 // getCount returns the count of timestamps to retrieve
-func (r *PDProtoTSORequest) getCount() uint32 {
+func (r *PDProtoRequest) getCount() uint32 {
 	return r.request.GetCount()
 }
 
 // process sends request and receive response via stream.
 // count defins the count of timestamps to retrieve.
-func (r *PDProtoTSORequest) process(forwardStream tsoStream, count uint32, tsoProtoFactory ProtoFactory) (tsoResp, error) {
+func (r *PDProtoRequest) process(forwardStream stream, count uint32, tsoProtoFactory ProtoFactory) (tsoResp, error) {
 	return forwardStream.process(r.request.GetHeader().GetClusterId(), count,
 		utils.DefaultKeyspaceID, utils.DefaultKeySpaceGroupID, r.request.GetDcLocation())
 }
 
 // postProcess sends the response back to the sender of the request
-func (r *PDProtoTSORequest) postProcess(countSum, physical, firstLogical int64, suffixBits uint32) (int64, error) {
+func (r *PDProtoRequest) postProcess(countSum, physical, firstLogical int64, suffixBits uint32) (int64, error) {
 	count := r.request.GetCount()
 	countSum += int64(count)
 	response := &pdpb.TsoResponse{
diff --git a/server/grpc_service.go b/server/grpc_service.go
index 7dd6e3440688..0d0b2928c642 100644
--- a/server/grpc_service.go
+++ b/server/grpc_service.go
@@ -226,12 +226,12 @@ func (s *GrpcServer) Tso(stream pdpb.PD_TsoServer) error {
 
 			var tsoProtoFactory tsoutil.ProtoFactory
 			if s.IsAPIServiceMode() {
-				tsoProtoFactory = s.TSOProtoFactory
+				tsoProtoFactory = s.tsoProtoFactory
 			} else {
-				tsoProtoFactory = s.PDProtoFactory
+				tsoProtoFactory = s.pdProtoFactory
 			}
 
-			tsoRequest := tsoutil.NewPDProtoTSORequest(forwardedHost, clientConn, request, stream)
+			tsoRequest := tsoutil.NewPDProtoRequest(forwardedHost, clientConn, request, stream)
 			s.tsoDispatcher.DispatchRequest(ctx, tsoRequest, tsoProtoFactory, doneCh, errCh)
 			continue
 		}
@@ -245,7 +245,7 @@ func (s *GrpcServer) Tso(stream pdpb.PD_TsoServer) error {
 			return status.Errorf(codes.FailedPrecondition, "mismatch cluster id, need %d but got %d", s.clusterID, request.GetHeader().GetClusterId())
 		}
 		count := request.GetCount()
-		ts, err := s.tsoAllocatorManager.HandleTSORequest(request.GetDcLocation(), count)
+		ts, err := s.tsoAllocatorManager.HandleRequest(request.GetDcLocation(), count)
 		if err != nil {
 			return status.Errorf(codes.Unknown, err.Error())
 		}
@@ -1321,7 +1321,7 @@ func (s *GrpcServer) UpdateServiceGCSafePoint(ctx context.Context, request *pdpb
 	if s.IsAPIServiceMode() {
 		nowTSO, err = s.getGlobalTSOFromTSOServer(ctx)
 	} else {
-		nowTSO, err = s.tsoAllocatorManager.HandleTSORequest(tso.GlobalDCLocation, 1)
+		nowTSO, err = s.tsoAllocatorManager.HandleRequest(tso.GlobalDCLocation, 1)
 	}
 	if err != nil {
 		return nil, err
@@ -2008,7 +2008,7 @@ func (s *GrpcServer) SetExternalTimestamp(ctx context.Context, request *pdpb.Set
 	if s.IsAPIServiceMode() {
 		nowTSO, err = s.getGlobalTSOFromTSOServer(ctx)
 	} else {
-		nowTSO, err = s.tsoAllocatorManager.HandleTSORequest(tso.GlobalDCLocation, 1)
+		nowTSO, err = s.tsoAllocatorManager.HandleRequest(tso.GlobalDCLocation, 1)
 	}
 	if err != nil {
 		return nil, err
diff --git a/server/server.go b/server/server.go
index 104f4223d5c2..a5039b1ea3bd 100644
--- a/server/server.go
+++ b/server/server.go
@@ -192,12 +192,12 @@ type Server struct {
 	// tsoDispatcher is used to dispatch different TSO requests to
 	// the corresponding forwarding TSO channel.
 	tsoDispatcher *tsoutil.TSODispatcher
-	// TSOProtoFactory is the abstract factory for creating tso
-	// related data structures defined in the TSO gPRC service
-	TSOProtoFactory *tsoutil.TSOProtoFactory
-	// TSOProtoFactory is the abstract factory for creating tso
-	// related data structures defined in the PD gPRC service
-	PDProtoFactory *tsoutil.PDProtoFactory
+	// tsoProtoFactory is the abstract factory for creating tso
+	// related data structures defined in the TSO grpc service
+	tsoProtoFactory *tsoutil.TSOProtoFactory
+	// pdProtoFactory is the abstract factory for creating tso
+	// related data structures defined in the PD grpc service
+	pdProtoFactory *tsoutil.PDProtoFactory
 
 	serviceRateLimiter *ratelimit.Limiter
 	serviceLabels      map[string][]apiutil.AccessPath
@@ -391,8 +391,8 @@ func (s *Server) startServer(ctx context.Context) error {
 	defaultStorage := storage.NewStorageWithEtcdBackend(s.client, s.rootPath)
 	s.storage = storage.NewCoreStorage(defaultStorage, regionStorage)
 	s.tsoDispatcher = tsoutil.NewTSODispatcher(tsoProxyHandleDuration, tsoProxyBatchSize)
-	s.TSOProtoFactory = &tsoutil.TSOProtoFactory{}
-	s.PDProtoFactory = &tsoutil.PDProtoFactory{}
+	s.tsoProtoFactory = &tsoutil.TSOProtoFactory{}
+	s.pdProtoFactory = &tsoutil.PDProtoFactory{}
 	if !s.IsAPIServiceMode() {
 		s.tsoAllocatorManager = tso.NewAllocatorManager(
 			s.member, s.rootPath, s.storage, s.cfg.IsLocalTSOEnabled(), s.cfg.GetTSOSaveInterval(), s.cfg.GetTSOUpdatePhysicalInterval(), s.cfg.GetTLSConfig(),