implement counter by key by WyRainBow · Pull Request #1390 · apache/dubbo-admin

WyRainBow · 2026-01-11T16:54:25Z

implement counter by key

Copilot

Pull request overview

This PR implements mesh-based grouping for the counter system, allowing statistics to be tracked and queried per mesh rather than only globally. The changes refactor the counter infrastructure from using atomic operations to map-based group tracking, and add initialization logic to populate counters from existing store data on startup.

Changes:

Refactored Counter and DistributionCounter to support group-based (mesh) counting instead of global atomic counters
Added CountByMesh and DistributionByMesh methods to the CounterManager interface for mesh-specific queries
Implemented counter initialization from the resource store on component startup to ensure accurate counts
Updated the overview API handler to support optional mesh query parameter for filtered statistics
Added mesh index to resource queries in discovery subscribers for improved query performance

Reviewed changes

Copilot reviewed 6 out of 6 changed files in this pull request and generated 9 comments.

Show a summary per file

File	Description
pkg/console/counter/counter.go	Refactored Counter and DistributionCounter from atomic operations to map-based group tracking
pkg/console/counter/manager.go	Added mesh-aware counting methods and updated event processing to track resources by mesh
pkg/console/counter/component.go	Added initialization logic to populate counters from existing store data on startup
pkg/console/handler/overview.go	Added support for optional mesh query parameter in cluster overview endpoint
pkg/core/discovery/subscriber/nacos_service.go	Added mesh index to resource queries for improved filtering
pkg/core/discovery/subscriber/instance.go	Added mesh index to instance resource queries for improved filtering

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-01-18T02:05:29Z

pkg/console/counter/manager.go

+func (cm *counterManager) CountByMesh(kind resmodel.ResourceKind, mesh string) int64 {
+	if mesh == "" {
+		mesh = "default"
+	}
+	if counter, exists := cm.simpleCounters[kind]; exists {
+		return counter.GetByGroup(mesh)
+	}
+	return 0
+}
+
+func (cm *counterManager) DistributionByMesh(metric CounterType, mesh string) map[string]int64 {
+	if mesh == "" {
+		mesh = "default"
 	}
-	return result
+	counter, exists := cm.distributionByType[metric]
+	if !exists {
+		return map[string]int64{}
+	}
+	return counter.GetByGroup(mesh)


The new mesh-based counting functionality introduced in CountByMesh and DistributionByMesh methods lacks test coverage. Given the complexity of the grouping logic and the presence of tests elsewhere in the repository, tests should be added to verify correct behavior for single mesh, multiple meshes, and edge cases like empty mesh names.

Copilot · 2026-01-18T02:05:29Z

pkg/console/counter/component.go

+		return fmt.Errorf("component %s does not implement store.Router", runtime.ResourceStore)
+	}
+
+	c.initializeCountsFromStore(storeRouter)


The error returned by initializeCountsFromStore is being ignored. If initialization fails, the counter manager will start with incorrect counts but the application will continue running. This should either return the error to fail fast, or log a warning if partial initialization is acceptable.

Suggested change

c.initializeCountsFromStore(storeRouter)

if err := c.initializeCountsFromStore(storeRouter); err != nil {

fmt.Printf("warning: failed to initialize counter manager from store: %v\n", err)

}

Copilot · 2026-01-18T02:05:29Z

pkg/console/counter/manager.go

 	if oldKey == newKey {
 		return
 	}
+	oldMesh := extractMeshName(oldObj)
+	newMesh := extractMeshName(newObj)


The update method only updates counters when oldKey != newKey, but it doesn't handle the case where the mesh changes while the key stays the same. This means if a resource moves from one mesh to another without changing its protocol/release/discovery value, the counters won't be updated correctly. The condition should check if either the key or mesh has changed.

Suggested change

if oldKey == newKey {

return

}

oldMesh := extractMeshName(oldObj)

newMesh := extractMeshName(newObj)

oldMesh := extractMeshName(oldObj)

newMesh := extractMeshName(newObj)

if oldKey == newKey && oldMesh == newMesh {

return

}

Copilot · 2026-01-18T02:05:30Z

pkg/console/counter/component.go

+		for mesh, count := range meshCounts {
+			for i := int64(0); i < count; i++ {
+				counter.Increment(mesh)
+			}
+		}
+	}
+
+	if kind == meshresource.InstanceKind {
+		for mesh, distributions := range meshDistributions {
+			for key, count := range distributions {
+				if len(key) > 9 && key[:9] == "protocol:" {
+					if cfg := cm.getDistributionConfig(kind, ProtocolCounter); cfg != nil {
+						for i := int64(0); i < count; i++ {
+							cfg.counter.Increment(mesh, key[9:])
+						}
+					}
+				} else if len(key) > 8 && key[:8] == "release:" {
+					if cfg := cm.getDistributionConfig(kind, ReleaseCounter); cfg != nil {
+						for i := int64(0); i < count; i++ {
+							cfg.counter.Increment(mesh, key[8:])
+						}
+					}
+				} else if len(key) > 11 && key[:11] == "discovery:" {
+					if cfg := cm.getDistributionConfig(kind, DiscoveryCounter); cfg != nil {
+						for i := int64(0); i < count; i++ {
+							cfg.counter.Increment(mesh, key[11:])


Using a loop to call Increment multiple times is inefficient. Consider adding a bulk increment method like IncrementBy(group string, count int64) to the Counter struct to improve performance during initialization.

Suggested change

for mesh, count := range meshCounts {

for i := int64(0); i < count; i++ {

counter.Increment(mesh)

}

}

}

if kind == meshresource.InstanceKind {

for mesh, distributions := range meshDistributions {

for key, count := range distributions {

if len(key) > 9 && key[:9] == "protocol:" {

if cfg := cm.getDistributionConfig(kind, ProtocolCounter); cfg != nil {

for i := int64(0); i < count; i++ {

cfg.counter.Increment(mesh, key[9:])

}

}

} else if len(key) > 8 && key[:8] == "release:" {

if cfg := cm.getDistributionConfig(kind, ReleaseCounter); cfg != nil {

for i := int64(0); i < count; i++ {

cfg.counter.Increment(mesh, key[8:])

}

}

} else if len(key) > 11 && key[:11] == "discovery:" {

if cfg := cm.getDistributionConfig(kind, DiscoveryCounter); cfg != nil {

for i := int64(0); i < count; i++ {

cfg.counter.Increment(mesh, key[11:])

// Use bulk increment when supported by the underlying counter implementation.

type bulkCounter interface {

IncrementBy(group string, count int64)

}

if bc, ok := counter.(bulkCounter); ok {

for mesh, count := range meshCounts {

bc.IncrementBy(mesh, count)

}

} else {

for mesh, count := range meshCounts {

for i := int64(0); i < count; i++ {

counter.Increment(mesh)

}

}

}

}

if kind == meshresource.InstanceKind {

// Use bulk increment when supported by the underlying distribution counter implementation.

type distBulkCounter interface {

IncrementBy(mesh, label string, count int64)

}

for mesh, distributions := range meshDistributions {

for key, count := range distributions {

if len(key) > 9 && key[:9] == "protocol:" {

if cfg := cm.getDistributionConfig(kind, ProtocolCounter); cfg != nil {

if bc, ok := cfg.counter.(distBulkCounter); ok {

bc.IncrementBy(mesh, key[9:], count)

} else {

for i := int64(0); i < count; i++ {

cfg.counter.Increment(mesh, key[9:])

}

}

}

} else if len(key) > 8 && key[:8] == "release:" {

if cfg := cm.getDistributionConfig(kind, ReleaseCounter); cfg != nil {

if bc, ok := cfg.counter.(distBulkCounter); ok {

bc.IncrementBy(mesh, key[8:], count)

} else {

for i := int64(0); i < count; i++ {

cfg.counter.Increment(mesh, key[8:])

}

}

}

} else if len(key) > 11 && key[:11] == "discovery:" {

if cfg := cm.getDistributionConfig(kind, DiscoveryCounter); cfg != nil {

if bc, ok := cfg.counter.(distBulkCounter); ok {

bc.IncrementBy(mesh, key[11:], count)

} else {

for i := int64(0); i < count; i++ {

cfg.counter.Increment(mesh, key[11:])

}

Copilot · 2026-01-18T02:05:30Z

pkg/console/counter/component.go

+				if len(key) > 9 && key[:9] == "protocol:" {
+					if cfg := cm.getDistributionConfig(kind, ProtocolCounter); cfg != nil {
+						for i := int64(0); i < count; i++ {
+							cfg.counter.Increment(mesh, key[9:])
+						}
+					}
+				} else if len(key) > 8 && key[:8] == "release:" {
+					if cfg := cm.getDistributionConfig(kind, ReleaseCounter); cfg != nil {
+						for i := int64(0); i < count; i++ {
+							cfg.counter.Increment(mesh, key[8:])
+						}
+					}
+				} else if len(key) > 11 && key[:11] == "discovery:" {
+					if cfg := cm.getDistributionConfig(kind, DiscoveryCounter); cfg != nil {
+						for i := int64(0); i < count; i++ {
+							cfg.counter.Increment(mesh, key[11:])
+						}
+					}
+				}


Using magic numbers for string prefix lengths (9, 8, 11) makes the code fragile and error-prone. Consider using constants or the strings.HasPrefix function with explicit prefix strings to make the code more maintainable and less prone to errors if the prefixes change.

Copilot · 2026-01-18T02:05:30Z

pkg/console/counter/counter.go

+func (c *Counter) Increment(group string) {
+	if group == "" {
+		group = "default"
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.data[group]++
+}
+
+func (c *Counter) Decrement(group string) {
+	if group == "" {
+		group = "default"
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if value, ok := c.data[group]; ok {
+		value--
+		if value <= 0 {
+			delete(c.data, group)
+		} else {
+			c.data[group] = value
 		}
 	}
 }


The Counter and DistributionCounter refactoring from atomic operations to map-based group tracking introduces significant complexity but lacks test coverage. Tests should verify thread safety, correct increment/decrement behavior per group, proper cleanup when counts reach zero, and the GetByGroup functionality.

Copilot · 2026-01-18T02:05:30Z

pkg/console/counter/component.go

+func (c *managerComponent) initializeCountsFromStore(storeRouter store.Router) error {
+	if err := c.initializeResourceCount(storeRouter, meshresource.InstanceKind); err != nil {
+		return fmt.Errorf("failed to initialize instance count: %w", err)
+	}
+
+	if err := c.initializeResourceCount(storeRouter, meshresource.ApplicationKind); err != nil {
+		return fmt.Errorf("failed to initialize application count: %w", err)
+	}
+
+	if err := c.initializeResourceCount(storeRouter, meshresource.ServiceProviderMetadataKind); err != nil {
+		return fmt.Errorf("failed to initialize service provider metadata count: %w", err)
+	}
+
+	return nil
+}
+
+func (c *managerComponent) initializeResourceCount(storeRouter store.Router, kind resmodel.ResourceKind) error {
+	resourceStore, err := storeRouter.ResourceKindRoute(kind)
+	if err != nil {
+		return err
+	}
+
+	allResources := resourceStore.List()
+
+	meshCounts := make(map[string]int64)
+	meshDistributions := make(map[string]map[string]int64)
+
+	for _, obj := range allResources {
+		resource, ok := obj.(resmodel.Resource)
+		if !ok {
+			continue
+		}
+
+		mesh := resource.ResourceMesh()
+		if mesh == "" {
+			mesh = "default"
+		}
+
+		meshCounts[mesh]++
+
+		if kind == meshresource.InstanceKind {
+			instance, ok := resource.(*meshresource.InstanceResource)
+			if ok && instance.Spec != nil {
+				protocol := instance.Spec.GetProtocol()
+				if protocol != "" {
+					if meshDistributions[mesh] == nil {
+						meshDistributions[mesh] = make(map[string]int64)
+					}
+					meshDistributions[mesh]["protocol:"+protocol]++
+				}
+
+				releaseVersion := instance.Spec.GetReleaseVersion()
+				if releaseVersion != "" {
+					if meshDistributions[mesh] == nil {
+						meshDistributions[mesh] = make(map[string]int64)
+					}
+					meshDistributions[mesh]["release:"+releaseVersion]++
+				}
+
+				if meshDistributions[mesh] == nil {
+					meshDistributions[mesh] = make(map[string]int64)
+				}
+				meshDistributions[mesh]["discovery:"+mesh]++
+			}
+		}
+	}
+
+	cm := c.manager.(*counterManager)
+
+	if counter, exists := cm.simpleCounters[kind]; exists {
+		for mesh, count := range meshCounts {
+			for i := int64(0); i < count; i++ {
+				counter.Increment(mesh)
+			}
+		}
+	}
+
+	if kind == meshresource.InstanceKind {
+		for mesh, distributions := range meshDistributions {
+			for key, count := range distributions {
+				if len(key) > 9 && key[:9] == "protocol:" {
+					if cfg := cm.getDistributionConfig(kind, ProtocolCounter); cfg != nil {
+						for i := int64(0); i < count; i++ {
+							cfg.counter.Increment(mesh, key[9:])
+						}
+					}
+				} else if len(key) > 8 && key[:8] == "release:" {
+					if cfg := cm.getDistributionConfig(kind, ReleaseCounter); cfg != nil {
+						for i := int64(0); i < count; i++ {
+							cfg.counter.Increment(mesh, key[8:])
+						}
+					}
+				} else if len(key) > 11 && key[:11] == "discovery:" {
+					if cfg := cm.getDistributionConfig(kind, DiscoveryCounter); cfg != nil {
+						for i := int64(0); i < count; i++ {
+							cfg.counter.Increment(mesh, key[11:])
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return nil
+}


The initializeCountsFromStore function, which is critical for ensuring correct counter initialization on startup, lacks test coverage. Tests should verify correct initialization from existing store data, proper handling of resources across multiple meshes, and correct distribution counter initialization for instances.

Copilot · 2026-01-18T02:05:31Z

pkg/console/counter/component.go

+				if len(key) > 9 && key[:9] == "protocol:" {
+					if cfg := cm.getDistributionConfig(kind, ProtocolCounter); cfg != nil {
+						for i := int64(0); i < count; i++ {
+							cfg.counter.Increment(mesh, key[9:])
+						}
+					}
+				} else if len(key) > 8 && key[:8] == "release:" {
+					if cfg := cm.getDistributionConfig(kind, ReleaseCounter); cfg != nil {
+						for i := int64(0); i < count; i++ {
+							cfg.counter.Increment(mesh, key[8:])
+						}
+					}
+				} else if len(key) > 11 && key[:11] == "discovery:" {
+					if cfg := cm.getDistributionConfig(kind, DiscoveryCounter); cfg != nil {
+						for i := int64(0); i < count; i++ {
+							cfg.counter.Increment(mesh, key[11:])
+						}
+					}


Using loops to call Increment multiple times is inefficient. Consider adding a bulk increment method to the DistributionCounter struct to improve performance during initialization, especially when dealing with large numbers of resources.

Copilot · 2026-01-18T02:05:31Z

pkg/console/counter/component.go

+				protocol := instance.Spec.GetProtocol()
+				if protocol != "" {
+					if meshDistributions[mesh] == nil {
+						meshDistributions[mesh] = make(map[string]int64)
+					}
+					meshDistributions[mesh]["protocol:"+protocol]++
+				}
+
+				releaseVersion := instance.Spec.GetReleaseVersion()
+				if releaseVersion != "" {
+					if meshDistributions[mesh] == nil {
+						meshDistributions[mesh] = make(map[string]int64)
+					}
+					meshDistributions[mesh]["release:"+releaseVersion]++
+				}
+
+				if meshDistributions[mesh] == nil {
+					meshDistributions[mesh] = make(map[string]int64)
+				}


The code repeatedly checks and initializes meshDistributions[mesh] on lines 137, 145, and 151. This logic should be refactored to initialize the map once at the beginning of the instance processing block to improve code clarity and avoid redundant checks.

Suggested change

protocol := instance.Spec.GetProtocol()

if protocol != "" {

if meshDistributions[mesh] == nil {

meshDistributions[mesh] = make(map[string]int64)

}

meshDistributions[mesh]["protocol:"+protocol]++

}

releaseVersion := instance.Spec.GetReleaseVersion()

if releaseVersion != "" {

if meshDistributions[mesh] == nil {

meshDistributions[mesh] = make(map[string]int64)

}

meshDistributions[mesh]["release:"+releaseVersion]++

}

if meshDistributions[mesh] == nil {

meshDistributions[mesh] = make(map[string]int64)

}

if meshDistributions[mesh] == nil {

meshDistributions[mesh] = make(map[string]int64)

}

protocol := instance.Spec.GetProtocol()

if protocol != "" {

meshDistributions[mesh]["protocol:"+protocol]++

}

releaseVersion := instance.Spec.GetReleaseVersion()

if releaseVersion != "" {

meshDistributions[mesh]["release:"+releaseVersion]++

}

robocanic

Great Work! I've left some comments, if you have any problems, discuss it with me.

robocanic · 2026-01-18T02:19:06Z

pkg/console/counter/component.go

+	if kind == meshresource.InstanceKind {
+		for mesh, distributions := range meshDistributions {
+			for key, count := range distributions {
+				if len(key) > 9 && key[:9] == "protocol:" {


Suggestion：这里的逻辑是不是能直接放到上面的for-loop里面，将对应的子类型increment，不需要再来一个map中转

Copilot

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated 4 comments.

Comments suppressed due to low confidence (1)

pkg/console/counter/counter.go:168

The newly added GetByGroup method lacks documentation. Public methods should have comments describing their purpose, parameters, and return values.

func (c *DistributionCounter) GetByGroup(group string) map[string]int64 {
	if group == "" {
		group = "default"
	}
	c.mu.RLock()
	defer c.mu.RUnlock()
	groupData, exists := c.data[group]
	if !exists {
		return map[string]int64{}
	}
	result := make(map[string]int64, len(groupData))
	for k, v := range groupData {
		result[k] = v
	}
	return result
}

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-01-21T11:10:17Z

pkg/console/counter/manager.go

-		counter.Decrement()
+		counter.Decrement(mesh)
+		logger.Debugf("CounterManager: Decrement %s for mesh=%s, current count=%d", counter.name, mesh, counter.GetByGroup(mesh))
 	case cache.Updated:


Simple counters do not handle mesh changes during update events. If a resource's mesh changes from "meshA" to "meshB" during an update, the counter for "meshA" should decrement and "meshB" should increment, but currently the update case is a no-op. This can lead to incorrect counts when resources move between meshes.

Suggested change

case cache.Updated:

case cache.Updated:

oldMesh := extractMeshName(event.OldObj())

newMesh := extractMeshName(event.NewObj())

if oldMesh != newMesh {

counter.Decrement(oldMesh)

logger.Debugf("CounterManager: Decrement %s for mesh=%s (Updated), current count=%d", counter.name, oldMesh, counter.GetByGroup(oldMesh))

counter.Increment(newMesh)

logger.Debugf("CounterManager: Increment %s for mesh=%s (Updated), current count=%d", counter.name, newMesh, counter.GetByGroup(newMesh))

}

Copilot · 2026-01-21T11:10:18Z

pkg/console/counter/manager.go

 	Distribution(metric CounterType) map[string]int64
+	CountByMesh(kind resmodel.ResourceKind, mesh string) int64


The newly added CountByMesh and DistributionByMesh methods lack documentation comments. Public interface methods should have comments describing their purpose, parameters, and return values to help API consumers understand how to use them.

Suggested change

Distribution(metric CounterType) map[string]int64

CountByMesh(kind resmodel.ResourceKind, mesh string) int64

Distribution(metric CounterType) map[string]int64

// CountByMesh returns the number of resources of the given kind that belong to the specified mesh.

// The mesh parameter identifies the mesh to filter on.

CountByMesh(kind resmodel.ResourceKind, mesh string) int64

// DistributionByMesh returns a distribution of counts for the given metric limited to the specified mesh.

// The returned map keys are metric values (for example, protocol or release) and the values are their counts.

Copilot · 2026-01-21T11:10:18Z

pkg/console/counter/counter.go

+func (c *Counter) GetByGroup(group string) int64 {
+	if group == "" {
+		group = "default"
+	}
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return c.data[group]
 }


The newly added GetByGroup method lacks documentation. Public methods should have comments describing their purpose, parameters, and return values.

robocanic

LGTM. Please merge the develop branch and I will merge into it.

sonarqubecloud · 2026-01-25T14:16:37Z

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud

WyRainBow · 2026-01-25T14:29:38Z

LGTM. Please merge the develop branch and I will merge into it.

ok

WyRainBow added 3 commits January 12, 2026 00:46

implement counter by key

4a00af6

merge: merge origin/develop

8f1cc85

chore: trigger CI

5e17b0a

WyRainBow force-pushed the feature/multi-discovery-counter-isolation branch from ae3f8eb to 5e17b0a Compare January 17, 2026 16:05

robocanic requested a review from Copilot January 18, 2026 02:02

Copilot started reviewing on behalf of robocanic January 18, 2026 02:02 View session

Copilot AI reviewed Jan 18, 2026

View reviewed changes

robocanic reviewed Jan 18, 2026

View reviewed changes

Fix counter initialization errors and mesh change detection logic

17329aa

WyRainBow force-pushed the feature/multi-discovery-counter-isolation branch from 9efa888 to 17329aa Compare January 20, 2026 09:45

robocanic requested review from Copilot and robocanic January 21, 2026 11:04

Copilot started reviewing on behalf of robocanic January 21, 2026 11:05 View session

Copilot AI reviewed Jan 21, 2026

View reviewed changes

robocanic approved these changes Jan 25, 2026

View reviewed changes

Merge branch 'develop' into feature/multi-discovery-counter-isolation

4587dfb

robocanic merged commit dc5eb0d into apache:develop Feb 1, 2026
5 checks passed

-	c.initializeCountsFromStore(storeRouter)
+	if err := c.initializeCountsFromStore(storeRouter); err != nil {
+		fmt.Printf("warning: failed to initialize counter manager from store: %v\n", err)
+	}

-	case cache.Updated:
+	case cache.Updated:
+		oldMesh := extractMeshName(event.OldObj())
+		newMesh := extractMeshName(event.NewObj())
+		if oldMesh != newMesh {
+			counter.Decrement(oldMesh)
+			logger.Debugf("CounterManager: Decrement %s for mesh=%s (Updated), current count=%d", counter.name, oldMesh, counter.GetByGroup(oldMesh))
+			counter.Increment(newMesh)
+			logger.Debugf("CounterManager: Increment %s for mesh=%s (Updated), current count=%d", counter.name, newMesh, counter.GetByGroup(newMesh))
+		}

		Distribution(metric CounterType) map[string]int64
		CountByMesh(kind resmodel.ResourceKind, mesh string) int64

Conversation

WyRainBow commented Jan 11, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Jan 18, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 18, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 18, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 18, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 18, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 18, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 18, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 18, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 18, 2026

Choose a reason for hiding this comment

Uh oh!

robocanic left a comment

Choose a reason for hiding this comment

Uh oh!

robocanic Jan 18, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Copilot AI Jan 21, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 21, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 21, 2026

Choose a reason for hiding this comment

Uh oh!

robocanic left a comment

Choose a reason for hiding this comment

Uh oh!

sonarqubecloud bot commented Jan 25, 2026

Quality Gate passed

Uh oh!

WyRainBow commented Jan 25, 2026

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants