Use empty namespace metrics tag if namespace not found (#3686)

* Use empty namespace metrics tag if namespace not found

Author: yux0

common/rpc/interceptor/caller_info_test.go

@@ -32,9 +32,10 @@ import (
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 	"go.temporal.io/api/workflowservice/v1"
+	"google.golang.org/grpc"
+
 	"go.temporal.io/server/common/headers"
 	"go.temporal.io/server/common/namespace"
-	"google.golang.org/grpc"
 )
 
 type (
@@ -71,6 +72,7 @@ func (s *callerInfoSuite) TestIntercept_CallerName() {
 	// testNamespaceID := namespace.NewID()
 	testNamespaceName := namespace.Name("test-namespace")
 	// s.mockRegistry.EXPECT().GetNamespaceName(testNamespaceID).Return(testNamespaceName, nil).AnyTimes()
+	s.mockRegistry.EXPECT().GetNamespace(gomock.Any()).Return(nil, nil).AnyTimes()
 
 	testCases := []struct {
 		setupIncomingCtx   func() context.Context
@@ -139,6 +141,8 @@ func (s *callerInfoSuite) TestIntercept_CallerName() {
 }
 
 func (s *callerInfoSuite) TestIntercept_CallerType() {
+	s.mockRegistry.EXPECT().GetNamespace(gomock.Any()).Return(nil, nil).AnyTimes()
+
 	testCases := []struct {
 		setupIncomingCtx   func() context.Context
 		request            interface{}
@@ -202,6 +206,7 @@ func (s *callerInfoSuite) TestIntercept_CallOrigin() {
 	serverInfo := &grpc.UnaryServerInfo{
 		FullMethod: "/temporal/" + method,
 	}
+	s.mockRegistry.EXPECT().GetNamespace(gomock.Any()).Return(nil, nil).AnyTimes()
 
 	testCases := []struct {
 		setupIncomingCtx   func() context.Context

common/rpc/interceptor/namespace.go

@@ -46,17 +46,22 @@ func GetNamespace(
 ) namespace.Name {
 	switch request := req.(type) {
 	case NamespaceNameGetter:
-		return namespace.Name(request.GetNamespace())
+		namespaceName := namespace.Name(request.GetNamespace())
+		_, err := namespaceRegistry.GetNamespace(namespaceName)
+		if err != nil {
+			return namespace.EmptyName
+		}
+		return namespaceName
 
 	case NamespaceIDGetter:
 		namespaceID := namespace.ID(request.GetNamespaceId())
 		namespaceName, err := namespaceRegistry.GetNamespaceName(namespaceID)
 		if err != nil {
-			return ""
+			return namespace.EmptyName
 		}
 		return namespaceName
 
 	default:
-		return ""
+		return namespace.EmptyName
 	}
 }

common/rpc/interceptor/namespace_test.go

@@ -25,20 +25,23 @@
 package interceptor
 
 import (
+	"errors"
 	"fmt"
 	"reflect"
 	"testing"
 
+	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 	"go.temporal.io/api/workflowservice/v1"
 
 	"go.temporal.io/server/api/historyservice/v1"
 	"go.temporal.io/server/api/matchingservice/v1"
+	"go.temporal.io/server/common/namespace"
 )
 
 type (
-	nameepaceSuite struct {
+	namespaceSuite struct {
 		suite.Suite
 		*require.Assertions
 	}
@@ -70,20 +73,20 @@ var (
 	}
 )
 
-func TestNameepaceSuite(t *testing.T) {
-	s := new(nameepaceSuite)
+func TestNamespaceSuite(t *testing.T) {
+	s := new(namespaceSuite)
 	suite.Run(t, s)
 }
 
-func (s *nameepaceSuite) SetupTest() {
+func (s *namespaceSuite) SetupTest() {
 	s.Assertions = require.New(s.T())
 }
 
-func (s *nameepaceSuite) TearDownTest() {
+func (s *namespaceSuite) TearDownTest() {
 
 }
 
-func (s *nameepaceSuite) TestFrontendAPIMetrics() {
+func (s *namespaceSuite) TestFrontendAPIMetrics() {
 	namespaceNameGetter := reflect.TypeOf((*NamespaceNameGetter)(nil)).Elem()
 
 	var service workflowservice.WorkflowServiceServer
@@ -108,7 +111,7 @@ func (s *nameepaceSuite) TestFrontendAPIMetrics() {
 	}
 }
 
-func (s *nameepaceSuite) TestMatchingAPIMetrics() {
+func (s *namespaceSuite) TestMatchingAPIMetrics() {
 	namespaceIDGetter := reflect.TypeOf((*NamespaceIDGetter)(nil)).Elem()
 
 	var service matchingservice.MatchingServiceServer
@@ -133,7 +136,7 @@ func (s *nameepaceSuite) TestMatchingAPIMetrics() {
 	}
 }
 
-func (s *nameepaceSuite) TestHistoryAPIMetrics() {
+func (s *namespaceSuite) TestHistoryAPIMetrics() {
 	namespaceIDGetter := reflect.TypeOf((*NamespaceIDGetter)(nil)).Elem()
 
 	var service historyservice.HistoryServiceServer
@@ -157,3 +160,37 @@ func (s *nameepaceSuite) TestHistoryAPIMetrics() {
 		}
 	}
 }
+
+func (s *namespaceSuite) TestGetNamespace() {
+	register := namespace.NewMockRegistry(gomock.NewController(s.T()))
+	register.EXPECT().GetNamespace(namespace.Name("exist")).Return(nil, nil)
+	register.EXPECT().GetNamespace(namespace.Name("nonexist")).Return(nil, errors.New("not found"))
+	register.EXPECT().GetNamespaceName(namespace.ID("exist")).Return(namespace.Name("exist"), nil)
+	register.EXPECT().GetNamespaceName(namespace.ID("nonexist")).Return(namespace.EmptyName, errors.New("not found"))
+	testCases := []struct {
+		method        interface{}
+		namespaceName namespace.Name
+	}{
+		{
+			&workflowservice.DescribeNamespaceRequest{Namespace: "exist"},
+			namespace.Name("exist"),
+		},
+		{
+			&workflowservice.DescribeNamespaceRequest{Namespace: "nonexist"},
+			namespace.EmptyName,
+		},
+		{
+			&historyservice.DescribeMutableStateRequest{NamespaceId: "exist"},
+			namespace.Name("exist"),
+		},
+		{
+			&historyservice.DescribeMutableStateRequest{NamespaceId: "nonexist"},
+			namespace.EmptyName,
+		},
+	}
+
+	for _, testCase := range testCases {
+		extractedNamespace := GetNamespace(register, testCase.method)
+		s.Equal(testCase.namespaceName, extractedNamespace)
+	}
+}