From 5fd0127da8825c930108f477dc253da819aa6690 Mon Sep 17 00:00:00 2001 From: Vytautas Date: Thu, 8 Sep 2022 10:24:34 +0300 Subject: [PATCH] Add domain_type and cluster_groups tags (#4990) * Add domain_type tag * Add cluster_group tag --- common/cache/domainCache.go | 16 ++++++++++++++++ common/cache/domainCache_test.go | 2 +- common/metrics/tags.go | 19 +++++++++++++++++++ common/resource/resourceImpl.go | 1 + host/onebox.go | 4 ++-- 5 files changed, 39 insertions(+), 3 deletions(-) diff --git a/common/cache/domainCache.go b/common/cache/domainCache.go index 0051360cf3d..462cb089012 100644 --- a/common/cache/domainCache.go +++ b/common/cache/domainCache.go @@ -27,12 +27,14 @@ import ( "hash/fnv" "sort" "strconv" + "strings" "sync" "sync/atomic" "time" "github.com/uber/cadence/common" "github.com/uber/cadence/common/clock" + "github.com/uber/cadence/common/cluster" "github.com/uber/cadence/common/errors" "github.com/uber/cadence/common/log" "github.com/uber/cadence/common/log/tag" @@ -99,6 +101,7 @@ type ( domainCache struct { status int32 shutdownChan chan struct{} + clusterGroup string cacheNameToID *atomic.Value cacheByID *atomic.Value domainManager persistence.DomainManager @@ -141,6 +144,7 @@ type ( // NewDomainCache creates a new instance of cache for holding onto domain information to reduce the load on persistence func NewDomainCache( domainManager persistence.DomainManager, + metadata cluster.Metadata, metricsClient metrics.Client, logger log.Logger, ) DomainCache { @@ -148,6 +152,7 @@ func NewDomainCache( cache := &domainCache{ status: domainCacheInitialized, shutdownChan: make(chan struct{}), + clusterGroup: getClusterGroupIdentifier(metadata), cacheNameToID: &atomic.Value{}, cacheByID: &atomic.Value{}, domainManager: domainManager, @@ -163,6 +168,15 @@ func NewDomainCache( return cache } +func getClusterGroupIdentifier(metadata cluster.Metadata) string { + var clusters []string + for cluster := range metadata.GetEnabledClusterInfo() { + clusters = append(clusters, cluster) + } + sort.Strings(clusters) + return strings.Join(clusters, "_") +} + func newDomainCache() Cache { return NewSimple(&SimpleOptions{ InitialCapacity: domainCacheInitialSize, @@ -464,6 +478,8 @@ UpdateLoop: c.scope.Tagged( metrics.DomainTag(nextEntry.info.Name), + metrics.DomainTypeTag(nextEntry.isGlobalDomain), + metrics.ClusterGroupTag(c.clusterGroup), metrics.ActiveClusterTag(nextEntry.replicationConfig.ActiveClusterName), ).UpdateGauge(metrics.ActiveClusterGauge, 1) diff --git a/common/cache/domainCache_test.go b/common/cache/domainCache_test.go index 49625099000..3641e6bc062 100644 --- a/common/cache/domainCache_test.go +++ b/common/cache/domainCache_test.go @@ -75,7 +75,7 @@ func (s *domainCacheSuite) SetupTest() { s.logger = loggerimpl.NewLoggerForTest(s.Suite) s.metadataMgr = &mocks.MetadataManager{} metricsClient := metrics.NewClient(tally.NoopScope, metrics.History) - s.domainCache = NewDomainCache(s.metadataMgr, metricsClient, s.logger).(*domainCache) + s.domainCache = NewDomainCache(s.metadataMgr, cluster.GetTestClusterMetadata(true), metricsClient, s.logger).(*domainCache) s.now = time.Now() s.domainCache.timeSource = clock.NewEventTimeSource().Update(s.now) diff --git a/common/metrics/tags.go b/common/metrics/tags.go index 57605793494..195f9cbc9fe 100644 --- a/common/metrics/tags.go +++ b/common/metrics/tags.go @@ -33,6 +33,8 @@ const ( instance = "instance" domain = "domain" + domainType = "domain_type" + clusterGroup = "cluster_group" sourceCluster = "source_cluster" targetCluster = "target_cluster" activeCluster = "active_cluster" @@ -83,11 +85,28 @@ func DomainTag(value string) Tag { return metricWithUnknown(domain, value) } +// DomainTypeTag returns a tag for domain type. +// This allows differentiating between global/local domains. +func DomainTypeTag(isGlobal bool) Tag { + var value string + if isGlobal { + value = "global" + } else { + value = "local" + } + return simpleMetric{key: domainType, value: value} +} + // DomainUnknownTag returns a new domain:unknown tag-value func DomainUnknownTag() Tag { return DomainTag("") } +// ClusterGroupTag return a new cluster group tag +func ClusterGroupTag(value string) Tag { + return simpleMetric{key: clusterGroup, value: value} +} + // InstanceTag returns a new instance tag func InstanceTag(value string) Tag { return simpleMetric{key: instance, value: value} diff --git a/common/resource/resourceImpl.go b/common/resource/resourceImpl.go index a07dea5251c..c8c67e30c73 100644 --- a/common/resource/resourceImpl.go +++ b/common/resource/resourceImpl.go @@ -183,6 +183,7 @@ func New( domainCache := cache.NewDomainCache( persistenceBean.GetDomainManager(), + params.ClusterMetadata, params.MetricsClient, logger, ) diff --git a/host/onebox.go b/host/onebox.go index 7e79366ccad..9a942d4900d 100644 --- a/host/onebox.go +++ b/host/onebox.go @@ -605,7 +605,7 @@ func (c *cadenceImpl) startWorker(hosts map[string][]membership.HostInfo, startW var replicatorDomainCache cache.DomainCache if c.workerConfig.EnableReplicator { metadataManager := persistence.NewDomainPersistenceMetricsClient(c.domainManager, service.GetMetricsClient(), c.logger, &c.persistenceConfig) - replicatorDomainCache = cache.NewDomainCache(metadataManager, service.GetMetricsClient(), service.GetLogger()) + replicatorDomainCache = cache.NewDomainCache(metadataManager, c.clusterMetadata, service.GetMetricsClient(), service.GetLogger()) replicatorDomainCache.Start() c.startWorkerReplicator(service) } @@ -613,7 +613,7 @@ func (c *cadenceImpl) startWorker(hosts map[string][]membership.HostInfo, startW var clientWorkerDomainCache cache.DomainCache if c.workerConfig.EnableArchiver { metadataProxyManager := persistence.NewDomainPersistenceMetricsClient(c.domainManager, service.GetMetricsClient(), c.logger, &c.persistenceConfig) - clientWorkerDomainCache = cache.NewDomainCache(metadataProxyManager, service.GetMetricsClient(), service.GetLogger()) + clientWorkerDomainCache = cache.NewDomainCache(metadataProxyManager, c.clusterMetadata, service.GetMetricsClient(), service.GetLogger()) clientWorkerDomainCache.Start() c.startWorkerClientWorker(params, service, clientWorkerDomainCache) }