[Improvement] Improve metric handling (#1728)

CHANGELOG.md

@@ -32,6 +32,7 @@
 - (Bugfix) Versioning Alignment
 - (Feature) (Scheduler) Merge Strategy
 - (Feature) (Networking) Endpoints Destination
+- (Improvement) Improve Metrics Handling
 
 ## [1.2.42](https://github.com/arangodb/kube-arangodb/tree/1.2.42) (2024-07-23)
 - (Maintenance) Go 1.22.4 & Kubernetes 1.29.6 libraries

docs/generated/metrics/README.md

@@ -13,8 +13,7 @@ has_toc: false
 [START_INJECT]: # (metricsTable)
 
 |                                                                 Name                                                                  |     Namespace      |         Group         |  Type   | Description                                                                           |
-|:-------------------------------------------------------------------------------------------------------------------------------------:|:-----------------:|:-----------------:|:-------:|:--------------------------------------------------------------------------------------|
-|                              [arango_operator_objects_processed](./arango_operator_objects_processed.md)                              |  arango_operator  |      objects      | Counter | Number of the processed objects                                                       |
+|:-------------------------------------------------------------------------------------------------------------------------------------:|:------------------:|:---------------------:|:-------:|:--------------------------------------------------------------------------------------|
 |                                [arangodb_operator_agency_errors](./arangodb_operator_agency_errors.md)                                | arangodb_operator  |        agency         | Counter | Current count of agency cache fetch errors                                            |
 |                               [arangodb_operator_agency_fetches](./arangodb_operator_agency_fetches.md)                               | arangodb_operator  |        agency         | Counter | Current count of agency cache fetches                                                 |
 |                                 [arangodb_operator_agency_index](./arangodb_operator_agency_index.md)                                 | arangodb_operator  |        agency         |  Gauge  | Current index of the agency cache                                                     |
@@ -33,6 +32,7 @@ has_toc: false
 |                   [arangodb_operator_kubernetes_client_requests](./arangodb_operator_kubernetes_client_requests.md)                   | arangodb_operator  |   kubernetes_client   | Counter | Number of Kubernetes Client requests                                                  |
 |                           [arangodb_operator_members_conditions](./arangodb_operator_members_conditions.md)                           | arangodb_operator  |        members        |  Gauge  | Representation of the ArangoMember condition state (true/false)                       |
 |      [arangodb_operator_members_unexpected_container_exit_codes](./arangodb_operator_members_unexpected_container_exit_codes.md)      | arangodb_operator  |        members        | Counter | Counter of unexpected restarts in pod (Containers/InitContainers/EphemeralContainers) |
+|                            [arangodb_operator_objects_processed](./arangodb_operator_objects_processed.md)                            | arangodb_operator  |        objects        | Counter | Number of the processed objects                                                       |
 |                           [arangodb_operator_rebalancer_enabled](./arangodb_operator_rebalancer_enabled.md)                           | arangodb_operator  |      rebalancer       |  Gauge  | Determines if rebalancer is enabled                                                   |
 |                     [arangodb_operator_rebalancer_moves_current](./arangodb_operator_rebalancer_moves_current.md)                     | arangodb_operator  |      rebalancer       |  Gauge  | Define how many moves are currently in progress                                       |
 |                      [arangodb_operator_rebalancer_moves_failed](./arangodb_operator_rebalancer_moves_failed.md)                      | arangodb_operator  |      rebalancer       | Counter | Define how many moves failed                                                          |
@@ -46,5 +46,7 @@ has_toc: false
 | [arangodb_operator_resources_arangodeployment_validation_errors](./arangodb_operator_resources_arangodeployment_validation_errors.md) | arangodb_operator  |       resources       | Counter | Counter for deployment validation errors                                              |
 | [arangodb_operator_resources_arangodeploymentreplication_active](./arangodb_operator_resources_arangodeploymentreplication_active.md) | arangodb_operator  |       resources       |  Gauge  | Defines if ArangoDeploymentReplication is configured and running                      |
 | [arangodb_operator_resources_arangodeploymentreplication_failed](./arangodb_operator_resources_arangodeploymentreplication_failed.md) | arangodb_operator  |       resources       |  Gauge  | Defines if ArangoDeploymentReplication is in Failed phase                             |
+|              [arangodb_resources_deployment_config_map_duration](./arangodb_resources_deployment_config_map_duration.md)              | arangodb_resources | deployment_config_map |  Gauge  | Duration of inspected ConfigMaps by Deployment in seconds                             |
+|             [arangodb_resources_deployment_config_map_inspected](./arangodb_resources_deployment_config_map_inspected.md)             | arangodb_resources | deployment_config_map | Counter | Number of inspected ConfigMaps by Deployment                                          |
 
 [END_INJECT]: # (metricsTable)

docs/generated/metrics/arangodb_operator_objects_processed.md

@@ -0,0 +1,17 @@
+---
+layout: page
+title: arangodb_operator_objects_processed
+parent: List of available metrics
+---
+
+# arangodb_operator_objects_processed (Counter)
+
+## Description
+
+Number of the processed objects
+
+## Labels
+
+|     Label     | Description   |
+|:-------------:|:--------------|
+| operator_name | Operator Name |

docs/generated/metrics/arangodb_resources_deployment_config_map_duration.md

@@ -0,0 +1,17 @@
+---
+layout: page
+title: arangodb_resources_deployment_config_map_duration
+parent: List of available metrics
+---
+
+# arangodb_resources_deployment_config_map_duration (Gauge)
+
+## Description
+
+Duration of inspected ConfigMaps by Deployment in seconds
+
+## Labels
+
+|   Label    | Description     |
+|:----------:|:----------------|
+| deployment | Deployment Name |

docs/generated/metrics/arangodb_resources_deployment_config_map_inspected.md

@@ -0,0 +1,17 @@
+---
+layout: page
+title: arangodb_resources_deployment_config_map_inspected
+parent: List of available metrics
+---
+
+# arangodb_resources_deployment_config_map_inspected (Counter)
+
+## Description
+
+Number of inspected ConfigMaps by Deployment
+
+## Labels
+
+|   Label    | Description     |
+|:----------:|:----------------|
+| deployment | Deployment Name |

internal/metrics.go

@@ -361,12 +361,12 @@ func generateMetricsGO(root string, in MetricsDoc) error {
 						"fname":            strings.Join(fnameParts, ""),
 						"ename":            strings.Join(tparts, ""),
 						"shortDescription": details.ShortDescription,
-						"global":           details.Global,
 						"labels":           generateLabels(details.Labels),
 						"type":             details.Type,
 						"mapTypes":         mapTypes,
 						"mapKeys":          mapKeys,
 						"mapIKeys":         mapIKeys,
+						"global":           details.Global,
 						"args":             strings.Join(params[1:], ", "),
 						"fparams":          strings.Join(params, ", "),
 						"fkeys":            strings.Join(keys, ", "),

internal/metrics.item.go.tmpl

@@ -23,154 +23,61 @@ package metric_descriptions
 
 import (
     "github.com/arangodb/kube-arangodb/pkg/util/metrics"
-{{- if .global }}
-
-	"sync"
-{{- end }}
 )
 
 var (
     {{ .fname }} = metrics.NewDescription("{{ .name }}", "{{ .shortDescription }}", {{ .labels }}, nil)
+{{- if .global }}
+
+    // Global Fields
+    global{{ .ename }}{{ .type }} = New{{ .ename }}{{ .type }}Factory()
+{{- end }}
 )
 
 func init() {
     registerDescription({{ .fname }})
 {{- if .global }}
-    registerCollector({{ .fname }}Global)
+	registerCollector(global{{ .ename }}{{ .type }})
 {{- end }}
 }
+{{- if .global }}
+
+func Global{{ .ename }}{{ .type }}() metrics.Factory{{ .type }}[{{ .ename }}Input] {
+    return global{{ .ename }}{{ .type }}
+}
+{{- end }}
+
+
+func New{{ .ename }}{{ .type }}Factory() metrics.Factory{{ .type }}[{{ .ename }}Input] {
+    return metrics.NewFactory{{ .type }}[{{ .ename }}Input]()
+}
+
+func New{{ .ename }}Input({{- range $i, $e := .mapKeys }}{{ if $i }}, {{ end }}{{ index $root.mapIKeys . }} {{ index $root.mapTypes . }}{{- end }}) {{ .ename }}Input {
+    return {{ .ename }}Input{
+{{- range .mapKeys }}
+        {{ . }}: {{ index $root.mapIKeys . }},
+{{- end }}
+    }
+}
+
+type {{ .ename }}Input struct {
+{{- range .mapKeys }}
+    {{ . }} {{ index $root.mapTypes . }} `json:"{{ index $root.mapIKeys . }}"`
+{{- end }}
+}
+
+func (i {{ .ename }}Input) {{ .type }}(value float64) metrics.Metric {
+    return {{ .ename }}{{ .type }}(value {{- range .mapKeys }}, i.{{ . }}{{- end }})
+}
+
+func (i {{ .ename }}Input) Desc() metrics.Description {
+    return {{ .ename }}()
+}
 
 func {{ .ename }}() metrics.Description {
     return {{ .fname }}
 }
 
-{{- if .global }}
-
-func {{ .ename }}Get({{ .args }}) float64 {
-    return {{ .fname }}Global.Get({{ .ename }}Item{
-{{- range $i, $field := .mapKeys }}
-        {{ $field }}: {{ index $root.mapIKeys $field }},
-{{- end }}
-    })
-}
-
-func {{ .ename }}Add({{ .fparams }}) {
-    {{ .fname }}Global.Add(value, {{ .ename }}Item{
-{{- range $i, $field := .mapKeys }}
-        {{ $field }}: {{ index $root.mapIKeys $field }},
-{{- end }}
-    })
-}
-{{- if eq .type "Counter" }}
-
-func {{ .ename }}Inc({{ .args }}) {
-    {{ .fname }}Global.Inc({{ .ename }}Item{
-{{- range $i, $field := .mapKeys }}
-        {{ $field }}: {{ index $root.mapIKeys $field }},
-{{- end }}
-    })
-}
-{{- end }}
-
-func Get{{ .ename }}Factory() {{ .ename }}Factory {
-    return {{ .fname }}Global
-}
-
-var {{ .fname }}Global = &{{ .fname }}Factory{
- items: {{ .fname }}Items{},
-}
-
-type {{ .ename }}Factory interface {
-    Get(object {{ .ename }}Item) float64
-    Add(value float64, object {{ .ename }}Item)
-    Remove(object {{ .ename }}Item)
-    Items() []{{ .ename }}Item
-{{- if eq .type "Counter" }}
-
-    Inc(object {{ .ename }}Item)
-{{- end }}
-}
-
-type {{ .fname }}Factory struct {
-    lock sync.RWMutex
-
-    items {{ .fname }}Items
-}
-
-func (a *{{ .fname }}Factory) Get(object {{ .ename }}Item) float64 {
-    a.lock.Lock()
-    defer a.lock.Unlock()
-
-    v, ok := a.items[object]
-    if !ok {
-        return 0
-    }
-
-    return v
-}
-
-func (a *{{ .fname }}Factory) Add(value float64, object {{ .ename }}Item) {
-    a.lock.Lock()
-    defer a.lock.Unlock()
-
-    v, ok := a.items[object]
-    if !ok {
-        a.items[object] = value
-        return
-    }
-
-    a.items[object] = value + v
-}
-
-func (a *{{ .fname }}Factory) Remove(obj {{ .ename }}Item) {
-    a.lock.Lock()
-    defer a.lock.Unlock()
-
-    delete(a.items, obj)
-}
-
-func (a *{{ .fname }}Factory) Items() []{{ .ename }}Item {
-    a.lock.Lock()
-    defer a.lock.Unlock()
-
-    var r = make([]{{ .ename }}Item, 0, len(a.items))
-
-    for k := range a.items {
-        r = append(r, k)
-    }
-
-    return r
-}
-{{- if eq .type "Counter" }}
-
-func (a *{{ .fname }}Factory) Inc(object {{ .ename }}Item) {
-    a.Add(1, object)
-}
-{{- end }}
-
-func (a *{{ .fname }}Factory) CollectMetrics(in metrics.PushMetric) {
-    a.lock.RLock()
-    defer a.lock.RUnlock()
-
-	for k, v := range a.items {
-	    in.Push({{ .fname }}.{{ .type }}(v{{- range .mapKeys }}, k.{{ . }}{{- end }}))
-	}
-}
-
-func (a *{{ .fname }}Factory) CollectDescriptions(in metrics.PushDescription) {
-	in.Push({{ .fname }})
-}
-
-type {{ .fname }}Items map[{{ .ename }}Item]float64
-
-type {{ .ename }}Item struct {
-{{- range .mapKeys }}
-    {{ . }} {{ index $root.mapTypes . }}
-{{- end }}
-}
-{{- else }}
-
 func {{ .ename }}{{ .type }}({{ .fparams }}) metrics.Metric {
     return {{ .ename }}().{{ .type }}({{ .fkeys }})
 }
-{{- end }}

internal/metrics.item.go_test.tmpl

@@ -23,28 +23,24 @@ package metric_descriptions
 
 import (
     "testing"
-{{- if .global }}
 
 	"github.com/stretchr/testify/require"
-{{- end }}
 )
 
 func Test_{{ .ename }}_Descriptor(t *testing.T) {
 	{{ .ename }}()
 }
 
-{{- if .global }}
+func Test_{{ .ename }}_Factory(t *testing.T) {
+	global := New{{ .ename }}{{ .type }}Factory()
 
-func Test_{{ .ename }}_Global(t *testing.T) {
-	global := Get{{ .ename }}Factory()
-
-	object1 := {{ .ename }}Item{
+	object1 := {{ .ename }}Input{
 {{- range $i, $field := .mapKeys }}
         {{ $field }}: "1",
 {{- end }}
 	}
 
-	object2 := {{ .ename }}Item{
+	object2 := {{ .ename }}Input{
 {{- range $i, $field := .mapKeys }}
         {{ $field }}: "2",
 {{- end }}
@@ -60,7 +56,7 @@ func Test_{{ .ename }}_Global(t *testing.T) {
 	})
 
 	t.Run("Add", func(t *testing.T) {
-	    global.Add(10, object1)
+	    global.Add(object1, 10)
 
 		require.EqualValues(t, 10, global.Get(object1))
 		require.EqualValues(t, 0, global.Get(object2))
@@ -71,7 +67,7 @@ func Test_{{ .ename }}_Global(t *testing.T) {
 	})
 
 	t.Run("Add", func(t *testing.T) {
-	    global.Add(3, object2)
+	    global.Add(object2, 3)
 
 		require.EqualValues(t, 10, global.Get(object1))
 		require.EqualValues(t, 3, global.Get(object2))
@@ -82,7 +78,7 @@ func Test_{{ .ename }}_Global(t *testing.T) {
 	})
 
 	t.Run("Dec", func(t *testing.T) {
-	    global.Add(-1, object1)
+	    global.Add(object1, -1)
 
 		require.EqualValues(t, 9, global.Get(object1))
 		require.EqualValues(t, 3, global.Get(object2))
@@ -127,16 +123,16 @@ func Test_{{ .ename }}_Global(t *testing.T) {
 }
 {{- if eq .type "Counter" }}
 
-func Test_{{ .ename }}_Global_Counter(t *testing.T) {
-	global := Get{{ .ename }}Factory()
+func Test_{{ .ename }}_Factory_Counter(t *testing.T) {
+	global := New{{ .ename }}{{ .type }}Factory()
 
-	object1 := {{ .ename }}Item{
+	object1 := {{ .ename }}Input{
 {{- range $i, $field := .mapKeys }}
         {{ $field }}: "1",
 {{- end }}
 	}
 
-	object2 := {{ .ename }}Item{
+	object2 := {{ .ename }}Input{
 {{- range $i, $field := .mapKeys }}
         {{ $field }}: "2",
 {{- end }}
@@ -152,7 +148,7 @@ func Test_{{ .ename }}_Global_Counter(t *testing.T) {
 	})
 
 	t.Run("Add", func(t *testing.T) {
-	    global.Add(10, object1)
+	    global.Add(object1, 10)
 
 		require.EqualValues(t, 10, global.Get(object1))
 		require.EqualValues(t, 0, global.Get(object2))
@@ -175,5 +171,54 @@ func Test_{{ .ename }}_Global_Counter(t *testing.T) {
 	})
 }
 {{- end }}
+{{- if eq .type "Gauge" }}
 
+func Test_{{ .ename }}_Factory_Gauge(t *testing.T) {
+	global := New{{ .ename }}{{ .type }}Factory()
+
+	object1 := {{ .ename }}Input{
+{{- range $i, $field := .mapKeys }}
+        {{ $field }}: "1",
 {{- end }}
+	}
+
+	object2 := {{ .ename }}Input{
+{{- range $i, $field := .mapKeys }}
+        {{ $field }}: "2",
+{{- end }}
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+	    global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+	    global.Set(object1, 3)
+	    global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}
+{{- end }}
+

internal/metrics.yaml

@@ -1,7 +1,25 @@
 documentation: docs/generated/metrics
 destination: pkg/generated/metric_descriptions
 namespaces:
-  arango_operator:
+  arangodb_resources:
+    deployment_config_map:
+      inspected:
+        shortDescription: "Number of inspected ConfigMaps by Deployment"
+        description: "Number of inspected ConfigMaps by Deployment"
+        type: "Counter"
+        global: true
+        labels:
+          - key: deployment
+            description: "Deployment Name"
+      duration:
+        shortDescription: "Duration of inspected ConfigMaps by Deployment in seconds"
+        description: "Duration of inspected ConfigMaps by Deployment in seconds"
+        type: "Gauge"
+        global: true
+        labels:
+          - key: deployment
+            description: "Deployment Name"
+  arangodb_operator:
     objects:
       processed:
         shortDescription: "Number of the processed objects"
@@ -11,7 +29,6 @@ namespaces:
         labels:
           - key: operator_name
             description: "Operator Name"
-  arangodb_operator:
     agency_cache:
       present:
         shortDescription: "Determines if local agency cache is present"

pkg/deployment/resources/config_maps.go

@@ -22,35 +22,28 @@ package resources
 
 import (
 	"context"
-	"time"
 
 	"github.com/arangodb/kube-arangodb/pkg/deployment/features"
-	"github.com/arangodb/kube-arangodb/pkg/metrics"
+	"github.com/arangodb/kube-arangodb/pkg/generated/metric_descriptions"
 	"github.com/arangodb/kube-arangodb/pkg/util/errors"
 	"github.com/arangodb/kube-arangodb/pkg/util/k8sutil"
 	inspectorInterface "github.com/arangodb/kube-arangodb/pkg/util/k8sutil/inspector"
-)
-
-var (
-	inspectedConfigMapsCounters     = metrics.MustRegisterCounterVec(metricsComponent, "inspected_config_maps", "Number of ConfigMaps inspections per deployment", metrics.DeploymentName)
-	inspectConfigMapsDurationGauges = metrics.MustRegisterGaugeVec(metricsComponent, "inspect_config_maps_duration", "Amount of time taken by a single inspection of all ConfigMaps for a deployment (in sec)", metrics.DeploymentName)
+	"github.com/arangodb/kube-arangodb/pkg/util/metrics"
 )
 
 // EnsureConfigMaps creates all ConfigMaps needed to run the given deployment
 func (r *Resources) EnsureConfigMaps(ctx context.Context, cachedStatus inspectorInterface.Inspector) error {
-	start := time.Now()
 	spec := r.context.GetSpec()
 	configMaps := cachedStatus.ConfigMapsModInterface().V1()
 	apiObject := r.context.GetAPIObject()
 	deploymentName := apiObject.GetName()
 
-	defer metrics.SetDuration(inspectConfigMapsDurationGauges.WithLabelValues(deploymentName), start)
-	counterMetric := inspectedConfigMapsCounters.WithLabelValues(deploymentName)
+	defer metrics.WithDuration(metric_descriptions.GlobalArangodbResourcesDeploymentConfigMapDurationGauge(), metric_descriptions.NewArangodbResourcesDeploymentConfigMapDurationInput(deploymentName))
 
 	reconcileRequired := k8sutil.NewReconcile(cachedStatus)
 
 	if features.IsGatewayEnabled(spec) {
-		counterMetric.Inc()
+		metric_descriptions.GlobalArangodbResourcesDeploymentConfigMapInspectedCounter().Inc(metric_descriptions.NewArangodbResourcesDeploymentConfigMapInspectedInput(deploymentName))
 		if err := reconcileRequired.WithError(r.ensureGatewayConfig(ctx, cachedStatus, configMaps)); err != nil {
 			return errors.Section(err, "Gateway ConfigMap")
 		}

pkg/generated/metric_descriptions/arango_operator_objects_processed.go

@@ -1,149 +0,0 @@
-//
-// DISCLAIMER
-//
-// Copyright 2016-2024 ArangoDB GmbH, Cologne, Germany
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Copyright holder is ArangoDB GmbH, Cologne, Germany
-//
-
-package metric_descriptions
-
-import (
-	"sync"
-
-	"github.com/arangodb/kube-arangodb/pkg/util/metrics"
-)
-
-var (
-	arangoOperatorObjectsProcessed = metrics.NewDescription("arango_operator_objects_processed", "Number of the processed objects", []string{`operator_name`}, nil)
-)
-
-func init() {
-	registerDescription(arangoOperatorObjectsProcessed)
-	registerCollector(arangoOperatorObjectsProcessedGlobal)
-}
-
-func ArangoOperatorObjectsProcessed() metrics.Description {
-	return arangoOperatorObjectsProcessed
-}
-
-func ArangoOperatorObjectsProcessedGet(operatorName string) float64 {
-	return arangoOperatorObjectsProcessedGlobal.Get(ArangoOperatorObjectsProcessedItem{
-		OperatorName: operatorName,
-	})
-}
-
-func ArangoOperatorObjectsProcessedAdd(value float64, operatorName string) {
-	arangoOperatorObjectsProcessedGlobal.Add(value, ArangoOperatorObjectsProcessedItem{
-		OperatorName: operatorName,
-	})
-}
-
-func ArangoOperatorObjectsProcessedInc(operatorName string) {
-	arangoOperatorObjectsProcessedGlobal.Inc(ArangoOperatorObjectsProcessedItem{
-		OperatorName: operatorName,
-	})
-}
-
-func GetArangoOperatorObjectsProcessedFactory() ArangoOperatorObjectsProcessedFactory {
-	return arangoOperatorObjectsProcessedGlobal
-}
-
-var arangoOperatorObjectsProcessedGlobal = &arangoOperatorObjectsProcessedFactory{
-	items: arangoOperatorObjectsProcessedItems{},
-}
-
-type ArangoOperatorObjectsProcessedFactory interface {
-	Get(object ArangoOperatorObjectsProcessedItem) float64
-	Add(value float64, object ArangoOperatorObjectsProcessedItem)
-	Remove(object ArangoOperatorObjectsProcessedItem)
-	Items() []ArangoOperatorObjectsProcessedItem
-
-	Inc(object ArangoOperatorObjectsProcessedItem)
-}
-
-type arangoOperatorObjectsProcessedFactory struct {
-	lock sync.RWMutex
-
-	items arangoOperatorObjectsProcessedItems
-}
-
-func (a *arangoOperatorObjectsProcessedFactory) Get(object ArangoOperatorObjectsProcessedItem) float64 {
-	a.lock.Lock()
-	defer a.lock.Unlock()
-
-	v, ok := a.items[object]
-	if !ok {
-		return 0
-	}
-
-	return v
-}
-
-func (a *arangoOperatorObjectsProcessedFactory) Add(value float64, object ArangoOperatorObjectsProcessedItem) {
-	a.lock.Lock()
-	defer a.lock.Unlock()
-
-	v, ok := a.items[object]
-	if !ok {
-		a.items[object] = value
-		return
-	}
-
-	a.items[object] = value + v
-}
-
-func (a *arangoOperatorObjectsProcessedFactory) Remove(obj ArangoOperatorObjectsProcessedItem) {
-	a.lock.Lock()
-	defer a.lock.Unlock()
-
-	delete(a.items, obj)
-}
-
-func (a *arangoOperatorObjectsProcessedFactory) Items() []ArangoOperatorObjectsProcessedItem {
-	a.lock.Lock()
-	defer a.lock.Unlock()
-
-	var r = make([]ArangoOperatorObjectsProcessedItem, 0, len(a.items))
-
-	for k := range a.items {
-		r = append(r, k)
-	}
-
-	return r
-}
-
-func (a *arangoOperatorObjectsProcessedFactory) Inc(object ArangoOperatorObjectsProcessedItem) {
-	a.Add(1, object)
-}
-
-func (a *arangoOperatorObjectsProcessedFactory) CollectMetrics(in metrics.PushMetric) {
-	a.lock.RLock()
-	defer a.lock.RUnlock()
-
-	for k, v := range a.items {
-		in.Push(arangoOperatorObjectsProcessed.Counter(v, k.OperatorName))
-	}
-}
-
-func (a *arangoOperatorObjectsProcessedFactory) CollectDescriptions(in metrics.PushDescription) {
-	in.Push(arangoOperatorObjectsProcessed)
-}
-
-type arangoOperatorObjectsProcessedItems map[ArangoOperatorObjectsProcessedItem]float64
-
-type ArangoOperatorObjectsProcessedItem struct {
-	OperatorName string
-}

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_health_present.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorAgencyCacheHealthPresent)
 }
 
+func NewArangodbOperatorAgencyCacheHealthPresentGaugeFactory() metrics.FactoryGauge[ArangodbOperatorAgencyCacheHealthPresentInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorAgencyCacheHealthPresentInput]()
+}
+
+func NewArangodbOperatorAgencyCacheHealthPresentInput(namespace string, name string) ArangodbOperatorAgencyCacheHealthPresentInput {
+	return ArangodbOperatorAgencyCacheHealthPresentInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorAgencyCacheHealthPresentInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorAgencyCacheHealthPresentInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorAgencyCacheHealthPresentGauge(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorAgencyCacheHealthPresentInput) Desc() metrics.Description {
+	return ArangodbOperatorAgencyCacheHealthPresent()
+}
+
 func ArangodbOperatorAgencyCacheHealthPresent() metrics.Description {
 	return arangodbOperatorAgencyCacheHealthPresent
 }

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_health_present_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorAgencyCacheHealthPresent_Descriptor(t *testing.T) {
 	ArangodbOperatorAgencyCacheHealthPresent()
 }
+
+func Test_ArangodbOperatorAgencyCacheHealthPresent_Factory(t *testing.T) {
+	global := NewArangodbOperatorAgencyCacheHealthPresentGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCacheHealthPresentInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCacheHealthPresentInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorAgencyCacheHealthPresent_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorAgencyCacheHealthPresentGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCacheHealthPresentInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCacheHealthPresentInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_healthy.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorAgencyCacheHealthy)
 }
 
+func NewArangodbOperatorAgencyCacheHealthyGaugeFactory() metrics.FactoryGauge[ArangodbOperatorAgencyCacheHealthyInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorAgencyCacheHealthyInput]()
+}
+
+func NewArangodbOperatorAgencyCacheHealthyInput(namespace string, name string) ArangodbOperatorAgencyCacheHealthyInput {
+	return ArangodbOperatorAgencyCacheHealthyInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorAgencyCacheHealthyInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorAgencyCacheHealthyInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorAgencyCacheHealthyGauge(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorAgencyCacheHealthyInput) Desc() metrics.Description {
+	return ArangodbOperatorAgencyCacheHealthy()
+}
+
 func ArangodbOperatorAgencyCacheHealthy() metrics.Description {
 	return arangodbOperatorAgencyCacheHealthy
 }

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_healthy_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorAgencyCacheHealthy_Descriptor(t *testing.T) {
 	ArangodbOperatorAgencyCacheHealthy()
 }
+
+func Test_ArangodbOperatorAgencyCacheHealthy_Factory(t *testing.T) {
+	global := NewArangodbOperatorAgencyCacheHealthyGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCacheHealthyInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCacheHealthyInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorAgencyCacheHealthy_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorAgencyCacheHealthyGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCacheHealthyInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCacheHealthyInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_leaders.go

@@ -32,6 +32,32 @@ func init() {
 	registerDescription(arangodbOperatorAgencyCacheLeaders)
 }
 
+func NewArangodbOperatorAgencyCacheLeadersGaugeFactory() metrics.FactoryGauge[ArangodbOperatorAgencyCacheLeadersInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorAgencyCacheLeadersInput]()
+}
+
+func NewArangodbOperatorAgencyCacheLeadersInput(namespace string, name string, agent string) ArangodbOperatorAgencyCacheLeadersInput {
+	return ArangodbOperatorAgencyCacheLeadersInput{
+		Namespace: namespace,
+		Name:      name,
+		Agent:     agent,
+	}
+}
+
+type ArangodbOperatorAgencyCacheLeadersInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+	Agent     string `json:"agent"`
+}
+
+func (i ArangodbOperatorAgencyCacheLeadersInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorAgencyCacheLeadersGauge(value, i.Namespace, i.Name, i.Agent)
+}
+
+func (i ArangodbOperatorAgencyCacheLeadersInput) Desc() metrics.Description {
+	return ArangodbOperatorAgencyCacheLeaders()
+}
+
 func ArangodbOperatorAgencyCacheLeaders() metrics.Description {
 	return arangodbOperatorAgencyCacheLeaders
 }

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_leaders_test.go

@@ -22,8 +22,149 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorAgencyCacheLeaders_Descriptor(t *testing.T) {
 	ArangodbOperatorAgencyCacheLeaders()
 }
+
+func Test_ArangodbOperatorAgencyCacheLeaders_Factory(t *testing.T) {
+	global := NewArangodbOperatorAgencyCacheLeadersGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCacheLeadersInput{
+		Namespace: "1",
+		Name:      "1",
+		Agent:     "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCacheLeadersInput{
+		Namespace: "2",
+		Name:      "2",
+		Agent:     "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorAgencyCacheLeaders_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorAgencyCacheLeadersGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCacheLeadersInput{
+		Namespace: "1",
+		Name:      "1",
+		Agent:     "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCacheLeadersInput{
+		Namespace: "2",
+		Name:      "2",
+		Agent:     "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_commit_offset.go

@@ -32,6 +32,32 @@ func init() {
 	registerDescription(arangodbOperatorAgencyCacheMemberCommitOffset)
 }
 
+func NewArangodbOperatorAgencyCacheMemberCommitOffsetGaugeFactory() metrics.FactoryGauge[ArangodbOperatorAgencyCacheMemberCommitOffsetInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorAgencyCacheMemberCommitOffsetInput]()
+}
+
+func NewArangodbOperatorAgencyCacheMemberCommitOffsetInput(namespace string, name string, agent string) ArangodbOperatorAgencyCacheMemberCommitOffsetInput {
+	return ArangodbOperatorAgencyCacheMemberCommitOffsetInput{
+		Namespace: namespace,
+		Name:      name,
+		Agent:     agent,
+	}
+}
+
+type ArangodbOperatorAgencyCacheMemberCommitOffsetInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+	Agent     string `json:"agent"`
+}
+
+func (i ArangodbOperatorAgencyCacheMemberCommitOffsetInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorAgencyCacheMemberCommitOffsetGauge(value, i.Namespace, i.Name, i.Agent)
+}
+
+func (i ArangodbOperatorAgencyCacheMemberCommitOffsetInput) Desc() metrics.Description {
+	return ArangodbOperatorAgencyCacheMemberCommitOffset()
+}
+
 func ArangodbOperatorAgencyCacheMemberCommitOffset() metrics.Description {
 	return arangodbOperatorAgencyCacheMemberCommitOffset
 }

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_commit_offset_test.go

@@ -22,8 +22,149 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorAgencyCacheMemberCommitOffset_Descriptor(t *testing.T) {
 	ArangodbOperatorAgencyCacheMemberCommitOffset()
 }
+
+func Test_ArangodbOperatorAgencyCacheMemberCommitOffset_Factory(t *testing.T) {
+	global := NewArangodbOperatorAgencyCacheMemberCommitOffsetGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCacheMemberCommitOffsetInput{
+		Namespace: "1",
+		Name:      "1",
+		Agent:     "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCacheMemberCommitOffsetInput{
+		Namespace: "2",
+		Name:      "2",
+		Agent:     "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorAgencyCacheMemberCommitOffset_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorAgencyCacheMemberCommitOffsetGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCacheMemberCommitOffsetInput{
+		Namespace: "1",
+		Name:      "1",
+		Agent:     "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCacheMemberCommitOffsetInput{
+		Namespace: "2",
+		Name:      "2",
+		Agent:     "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_serving.go

@@ -32,6 +32,32 @@ func init() {
 	registerDescription(arangodbOperatorAgencyCacheMemberServing)
 }
 
+func NewArangodbOperatorAgencyCacheMemberServingGaugeFactory() metrics.FactoryGauge[ArangodbOperatorAgencyCacheMemberServingInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorAgencyCacheMemberServingInput]()
+}
+
+func NewArangodbOperatorAgencyCacheMemberServingInput(namespace string, name string, agent string) ArangodbOperatorAgencyCacheMemberServingInput {
+	return ArangodbOperatorAgencyCacheMemberServingInput{
+		Namespace: namespace,
+		Name:      name,
+		Agent:     agent,
+	}
+}
+
+type ArangodbOperatorAgencyCacheMemberServingInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+	Agent     string `json:"agent"`
+}
+
+func (i ArangodbOperatorAgencyCacheMemberServingInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorAgencyCacheMemberServingGauge(value, i.Namespace, i.Name, i.Agent)
+}
+
+func (i ArangodbOperatorAgencyCacheMemberServingInput) Desc() metrics.Description {
+	return ArangodbOperatorAgencyCacheMemberServing()
+}
+
 func ArangodbOperatorAgencyCacheMemberServing() metrics.Description {
 	return arangodbOperatorAgencyCacheMemberServing
 }

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_serving_test.go

@@ -22,8 +22,149 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorAgencyCacheMemberServing_Descriptor(t *testing.T) {
 	ArangodbOperatorAgencyCacheMemberServing()
 }
+
+func Test_ArangodbOperatorAgencyCacheMemberServing_Factory(t *testing.T) {
+	global := NewArangodbOperatorAgencyCacheMemberServingGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCacheMemberServingInput{
+		Namespace: "1",
+		Name:      "1",
+		Agent:     "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCacheMemberServingInput{
+		Namespace: "2",
+		Name:      "2",
+		Agent:     "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorAgencyCacheMemberServing_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorAgencyCacheMemberServingGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCacheMemberServingInput{
+		Namespace: "1",
+		Name:      "1",
+		Agent:     "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCacheMemberServingInput{
+		Namespace: "2",
+		Name:      "2",
+		Agent:     "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_present.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorAgencyCachePresent)
 }
 
+func NewArangodbOperatorAgencyCachePresentGaugeFactory() metrics.FactoryGauge[ArangodbOperatorAgencyCachePresentInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorAgencyCachePresentInput]()
+}
+
+func NewArangodbOperatorAgencyCachePresentInput(namespace string, name string) ArangodbOperatorAgencyCachePresentInput {
+	return ArangodbOperatorAgencyCachePresentInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorAgencyCachePresentInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorAgencyCachePresentInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorAgencyCachePresentGauge(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorAgencyCachePresentInput) Desc() metrics.Description {
+	return ArangodbOperatorAgencyCachePresent()
+}
+
 func ArangodbOperatorAgencyCachePresent() metrics.Description {
 	return arangodbOperatorAgencyCachePresent
 }

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_present_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorAgencyCachePresent_Descriptor(t *testing.T) {
 	ArangodbOperatorAgencyCachePresent()
 }
+
+func Test_ArangodbOperatorAgencyCachePresent_Factory(t *testing.T) {
+	global := NewArangodbOperatorAgencyCachePresentGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCachePresentInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCachePresentInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorAgencyCachePresent_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorAgencyCachePresentGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCachePresentInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCachePresentInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_serving.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorAgencyCacheServing)
 }
 
+func NewArangodbOperatorAgencyCacheServingGaugeFactory() metrics.FactoryGauge[ArangodbOperatorAgencyCacheServingInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorAgencyCacheServingInput]()
+}
+
+func NewArangodbOperatorAgencyCacheServingInput(namespace string, name string) ArangodbOperatorAgencyCacheServingInput {
+	return ArangodbOperatorAgencyCacheServingInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorAgencyCacheServingInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorAgencyCacheServingInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorAgencyCacheServingGauge(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorAgencyCacheServingInput) Desc() metrics.Description {
+	return ArangodbOperatorAgencyCacheServing()
+}
+
 func ArangodbOperatorAgencyCacheServing() metrics.Description {
 	return arangodbOperatorAgencyCacheServing
 }

pkg/generated/metric_descriptions/arangodb_operator_agency_cache_serving_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorAgencyCacheServing_Descriptor(t *testing.T) {
 	ArangodbOperatorAgencyCacheServing()
 }
+
+func Test_ArangodbOperatorAgencyCacheServing_Factory(t *testing.T) {
+	global := NewArangodbOperatorAgencyCacheServingGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCacheServingInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCacheServingInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorAgencyCacheServing_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorAgencyCacheServingGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyCacheServingInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyCacheServingInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_agency_errors.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorAgencyErrors)
 }
 
+func NewArangodbOperatorAgencyErrorsCounterFactory() metrics.FactoryCounter[ArangodbOperatorAgencyErrorsInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorAgencyErrorsInput]()
+}
+
+func NewArangodbOperatorAgencyErrorsInput(namespace string, name string) ArangodbOperatorAgencyErrorsInput {
+	return ArangodbOperatorAgencyErrorsInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorAgencyErrorsInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorAgencyErrorsInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorAgencyErrorsCounter(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorAgencyErrorsInput) Desc() metrics.Description {
+	return ArangodbOperatorAgencyErrors()
+}
+
 func ArangodbOperatorAgencyErrors() metrics.Description {
 	return arangodbOperatorAgencyErrors
 }

pkg/generated/metric_descriptions/arangodb_operator_agency_errors_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorAgencyErrors_Descriptor(t *testing.T) {
 	ArangodbOperatorAgencyErrors()
 }
+
+func Test_ArangodbOperatorAgencyErrors_Factory(t *testing.T) {
+	global := NewArangodbOperatorAgencyErrorsCounterFactory()
+
+	object1 := ArangodbOperatorAgencyErrorsInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyErrorsInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorAgencyErrors_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorAgencyErrorsCounterFactory()
+
+	object1 := ArangodbOperatorAgencyErrorsInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyErrorsInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_agency_fetches.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorAgencyFetches)
 }
 
+func NewArangodbOperatorAgencyFetchesCounterFactory() metrics.FactoryCounter[ArangodbOperatorAgencyFetchesInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorAgencyFetchesInput]()
+}
+
+func NewArangodbOperatorAgencyFetchesInput(namespace string, name string) ArangodbOperatorAgencyFetchesInput {
+	return ArangodbOperatorAgencyFetchesInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorAgencyFetchesInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorAgencyFetchesInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorAgencyFetchesCounter(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorAgencyFetchesInput) Desc() metrics.Description {
+	return ArangodbOperatorAgencyFetches()
+}
+
 func ArangodbOperatorAgencyFetches() metrics.Description {
 	return arangodbOperatorAgencyFetches
 }

pkg/generated/metric_descriptions/arangodb_operator_agency_fetches_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorAgencyFetches_Descriptor(t *testing.T) {
 	ArangodbOperatorAgencyFetches()
 }
+
+func Test_ArangodbOperatorAgencyFetches_Factory(t *testing.T) {
+	global := NewArangodbOperatorAgencyFetchesCounterFactory()
+
+	object1 := ArangodbOperatorAgencyFetchesInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyFetchesInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorAgencyFetches_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorAgencyFetchesCounterFactory()
+
+	object1 := ArangodbOperatorAgencyFetchesInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyFetchesInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_agency_index.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorAgencyIndex)
 }
 
+func NewArangodbOperatorAgencyIndexGaugeFactory() metrics.FactoryGauge[ArangodbOperatorAgencyIndexInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorAgencyIndexInput]()
+}
+
+func NewArangodbOperatorAgencyIndexInput(namespace string, name string) ArangodbOperatorAgencyIndexInput {
+	return ArangodbOperatorAgencyIndexInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorAgencyIndexInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorAgencyIndexInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorAgencyIndexGauge(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorAgencyIndexInput) Desc() metrics.Description {
+	return ArangodbOperatorAgencyIndex()
+}
+
 func ArangodbOperatorAgencyIndex() metrics.Description {
 	return arangodbOperatorAgencyIndex
 }

pkg/generated/metric_descriptions/arangodb_operator_agency_index_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorAgencyIndex_Descriptor(t *testing.T) {
 	ArangodbOperatorAgencyIndex()
 }
+
+func Test_ArangodbOperatorAgencyIndex_Factory(t *testing.T) {
+	global := NewArangodbOperatorAgencyIndexGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyIndexInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyIndexInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorAgencyIndex_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorAgencyIndexGaugeFactory()
+
+	object1 := ArangodbOperatorAgencyIndexInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorAgencyIndexInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_deployment_conditions.go

@@ -32,6 +32,32 @@ func init() {
 	registerDescription(arangodbOperatorDeploymentConditions)
 }
 
+func NewArangodbOperatorDeploymentConditionsGaugeFactory() metrics.FactoryGauge[ArangodbOperatorDeploymentConditionsInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorDeploymentConditionsInput]()
+}
+
+func NewArangodbOperatorDeploymentConditionsInput(namespace string, name string, condition string) ArangodbOperatorDeploymentConditionsInput {
+	return ArangodbOperatorDeploymentConditionsInput{
+		Namespace: namespace,
+		Name:      name,
+		Condition: condition,
+	}
+}
+
+type ArangodbOperatorDeploymentConditionsInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+	Condition string `json:"condition"`
+}
+
+func (i ArangodbOperatorDeploymentConditionsInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorDeploymentConditionsGauge(value, i.Namespace, i.Name, i.Condition)
+}
+
+func (i ArangodbOperatorDeploymentConditionsInput) Desc() metrics.Description {
+	return ArangodbOperatorDeploymentConditions()
+}
+
 func ArangodbOperatorDeploymentConditions() metrics.Description {
 	return arangodbOperatorDeploymentConditions
 }

pkg/generated/metric_descriptions/arangodb_operator_deployment_conditions_test.go

@@ -22,8 +22,149 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorDeploymentConditions_Descriptor(t *testing.T) {
 	ArangodbOperatorDeploymentConditions()
 }
+
+func Test_ArangodbOperatorDeploymentConditions_Factory(t *testing.T) {
+	global := NewArangodbOperatorDeploymentConditionsGaugeFactory()
+
+	object1 := ArangodbOperatorDeploymentConditionsInput{
+		Namespace: "1",
+		Name:      "1",
+		Condition: "1",
+	}
+
+	object2 := ArangodbOperatorDeploymentConditionsInput{
+		Namespace: "2",
+		Name:      "2",
+		Condition: "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorDeploymentConditions_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorDeploymentConditionsGaugeFactory()
+
+	object1 := ArangodbOperatorDeploymentConditionsInput{
+		Namespace: "1",
+		Name:      "1",
+		Condition: "1",
+	}
+
+	object2 := ArangodbOperatorDeploymentConditionsInput{
+		Namespace: "2",
+		Name:      "2",
+		Condition: "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_engine_assertions.go

@@ -32,6 +32,28 @@ func init() {
 	registerDescription(arangodbOperatorEngineAssertions)
 }
 
+func NewArangodbOperatorEngineAssertionsCounterFactory() metrics.FactoryCounter[ArangodbOperatorEngineAssertionsInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorEngineAssertionsInput]()
+}
+
+func NewArangodbOperatorEngineAssertionsInput(key string) ArangodbOperatorEngineAssertionsInput {
+	return ArangodbOperatorEngineAssertionsInput{
+		Key: key,
+	}
+}
+
+type ArangodbOperatorEngineAssertionsInput struct {
+	Key string `json:"key"`
+}
+
+func (i ArangodbOperatorEngineAssertionsInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorEngineAssertionsCounter(value, i.Key)
+}
+
+func (i ArangodbOperatorEngineAssertionsInput) Desc() metrics.Description {
+	return ArangodbOperatorEngineAssertions()
+}
+
 func ArangodbOperatorEngineAssertions() metrics.Description {
 	return arangodbOperatorEngineAssertions
 }

pkg/generated/metric_descriptions/arangodb_operator_engine_assertions_test.go

@@ -22,8 +22,141 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorEngineAssertions_Descriptor(t *testing.T) {
 	ArangodbOperatorEngineAssertions()
 }
+
+func Test_ArangodbOperatorEngineAssertions_Factory(t *testing.T) {
+	global := NewArangodbOperatorEngineAssertionsCounterFactory()
+
+	object1 := ArangodbOperatorEngineAssertionsInput{
+		Key: "1",
+	}
+
+	object2 := ArangodbOperatorEngineAssertionsInput{
+		Key: "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorEngineAssertions_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorEngineAssertionsCounterFactory()
+
+	object1 := ArangodbOperatorEngineAssertionsInput{
+		Key: "1",
+	}
+
+	object2 := ArangodbOperatorEngineAssertionsInput{
+		Key: "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_engine_ops_alerts.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorEngineOpsAlerts)
 }
 
+func NewArangodbOperatorEngineOpsAlertsCounterFactory() metrics.FactoryCounter[ArangodbOperatorEngineOpsAlertsInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorEngineOpsAlertsInput]()
+}
+
+func NewArangodbOperatorEngineOpsAlertsInput(namespace string, name string) ArangodbOperatorEngineOpsAlertsInput {
+	return ArangodbOperatorEngineOpsAlertsInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorEngineOpsAlertsInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorEngineOpsAlertsInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorEngineOpsAlertsCounter(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorEngineOpsAlertsInput) Desc() metrics.Description {
+	return ArangodbOperatorEngineOpsAlerts()
+}
+
 func ArangodbOperatorEngineOpsAlerts() metrics.Description {
 	return arangodbOperatorEngineOpsAlerts
 }

pkg/generated/metric_descriptions/arangodb_operator_engine_ops_alerts_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorEngineOpsAlerts_Descriptor(t *testing.T) {
 	ArangodbOperatorEngineOpsAlerts()
 }
+
+func Test_ArangodbOperatorEngineOpsAlerts_Factory(t *testing.T) {
+	global := NewArangodbOperatorEngineOpsAlertsCounterFactory()
+
+	object1 := ArangodbOperatorEngineOpsAlertsInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorEngineOpsAlertsInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorEngineOpsAlerts_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorEngineOpsAlertsCounterFactory()
+
+	object1 := ArangodbOperatorEngineOpsAlertsInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorEngineOpsAlertsInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_engine_panics_recovered.go

@@ -32,6 +32,28 @@ func init() {
 	registerDescription(arangodbOperatorEnginePanicsRecovered)
 }
 
+func NewArangodbOperatorEnginePanicsRecoveredCounterFactory() metrics.FactoryCounter[ArangodbOperatorEnginePanicsRecoveredInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorEnginePanicsRecoveredInput]()
+}
+
+func NewArangodbOperatorEnginePanicsRecoveredInput(section string) ArangodbOperatorEnginePanicsRecoveredInput {
+	return ArangodbOperatorEnginePanicsRecoveredInput{
+		Section: section,
+	}
+}
+
+type ArangodbOperatorEnginePanicsRecoveredInput struct {
+	Section string `json:"section"`
+}
+
+func (i ArangodbOperatorEnginePanicsRecoveredInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorEnginePanicsRecoveredCounter(value, i.Section)
+}
+
+func (i ArangodbOperatorEnginePanicsRecoveredInput) Desc() metrics.Description {
+	return ArangodbOperatorEnginePanicsRecovered()
+}
+
 func ArangodbOperatorEnginePanicsRecovered() metrics.Description {
 	return arangodbOperatorEnginePanicsRecovered
 }

pkg/generated/metric_descriptions/arangodb_operator_engine_panics_recovered_test.go

@@ -22,8 +22,141 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorEnginePanicsRecovered_Descriptor(t *testing.T) {
 	ArangodbOperatorEnginePanicsRecovered()
 }
+
+func Test_ArangodbOperatorEnginePanicsRecovered_Factory(t *testing.T) {
+	global := NewArangodbOperatorEnginePanicsRecoveredCounterFactory()
+
+	object1 := ArangodbOperatorEnginePanicsRecoveredInput{
+		Section: "1",
+	}
+
+	object2 := ArangodbOperatorEnginePanicsRecoveredInput{
+		Section: "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorEnginePanicsRecovered_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorEnginePanicsRecoveredCounterFactory()
+
+	object1 := ArangodbOperatorEnginePanicsRecoveredInput{
+		Section: "1",
+	}
+
+	object2 := ArangodbOperatorEnginePanicsRecoveredInput{
+		Section: "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_request_errors.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorKubernetesClientRequestErrors)
 }
 
+func NewArangodbOperatorKubernetesClientRequestErrorsCounterFactory() metrics.FactoryCounter[ArangodbOperatorKubernetesClientRequestErrorsInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorKubernetesClientRequestErrorsInput]()
+}
+
+func NewArangodbOperatorKubernetesClientRequestErrorsInput(component string, verb string) ArangodbOperatorKubernetesClientRequestErrorsInput {
+	return ArangodbOperatorKubernetesClientRequestErrorsInput{
+		Component: component,
+		Verb:      verb,
+	}
+}
+
+type ArangodbOperatorKubernetesClientRequestErrorsInput struct {
+	Component string `json:"component"`
+	Verb      string `json:"verb"`
+}
+
+func (i ArangodbOperatorKubernetesClientRequestErrorsInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorKubernetesClientRequestErrorsCounter(value, i.Component, i.Verb)
+}
+
+func (i ArangodbOperatorKubernetesClientRequestErrorsInput) Desc() metrics.Description {
+	return ArangodbOperatorKubernetesClientRequestErrors()
+}
+
 func ArangodbOperatorKubernetesClientRequestErrors() metrics.Description {
 	return arangodbOperatorKubernetesClientRequestErrors
 }

pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_request_errors_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorKubernetesClientRequestErrors_Descriptor(t *testing.T) {
 	ArangodbOperatorKubernetesClientRequestErrors()
 }
+
+func Test_ArangodbOperatorKubernetesClientRequestErrors_Factory(t *testing.T) {
+	global := NewArangodbOperatorKubernetesClientRequestErrorsCounterFactory()
+
+	object1 := ArangodbOperatorKubernetesClientRequestErrorsInput{
+		Component: "1",
+		Verb:      "1",
+	}
+
+	object2 := ArangodbOperatorKubernetesClientRequestErrorsInput{
+		Component: "2",
+		Verb:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorKubernetesClientRequestErrors_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorKubernetesClientRequestErrorsCounterFactory()
+
+	object1 := ArangodbOperatorKubernetesClientRequestErrorsInput{
+		Component: "1",
+		Verb:      "1",
+	}
+
+	object2 := ArangodbOperatorKubernetesClientRequestErrorsInput{
+		Component: "2",
+		Verb:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_requests.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorKubernetesClientRequests)
 }
 
+func NewArangodbOperatorKubernetesClientRequestsCounterFactory() metrics.FactoryCounter[ArangodbOperatorKubernetesClientRequestsInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorKubernetesClientRequestsInput]()
+}
+
+func NewArangodbOperatorKubernetesClientRequestsInput(component string, verb string) ArangodbOperatorKubernetesClientRequestsInput {
+	return ArangodbOperatorKubernetesClientRequestsInput{
+		Component: component,
+		Verb:      verb,
+	}
+}
+
+type ArangodbOperatorKubernetesClientRequestsInput struct {
+	Component string `json:"component"`
+	Verb      string `json:"verb"`
+}
+
+func (i ArangodbOperatorKubernetesClientRequestsInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorKubernetesClientRequestsCounter(value, i.Component, i.Verb)
+}
+
+func (i ArangodbOperatorKubernetesClientRequestsInput) Desc() metrics.Description {
+	return ArangodbOperatorKubernetesClientRequests()
+}
+
 func ArangodbOperatorKubernetesClientRequests() metrics.Description {
 	return arangodbOperatorKubernetesClientRequests
 }

pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_requests_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorKubernetesClientRequests_Descriptor(t *testing.T) {
 	ArangodbOperatorKubernetesClientRequests()
 }
+
+func Test_ArangodbOperatorKubernetesClientRequests_Factory(t *testing.T) {
+	global := NewArangodbOperatorKubernetesClientRequestsCounterFactory()
+
+	object1 := ArangodbOperatorKubernetesClientRequestsInput{
+		Component: "1",
+		Verb:      "1",
+	}
+
+	object2 := ArangodbOperatorKubernetesClientRequestsInput{
+		Component: "2",
+		Verb:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorKubernetesClientRequests_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorKubernetesClientRequestsCounterFactory()
+
+	object1 := ArangodbOperatorKubernetesClientRequestsInput{
+		Component: "1",
+		Verb:      "1",
+	}
+
+	object2 := ArangodbOperatorKubernetesClientRequestsInput{
+		Component: "2",
+		Verb:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_members_conditions.go

@@ -32,6 +32,34 @@ func init() {
 	registerDescription(arangodbOperatorMembersConditions)
 }
 
+func NewArangodbOperatorMembersConditionsGaugeFactory() metrics.FactoryGauge[ArangodbOperatorMembersConditionsInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorMembersConditionsInput]()
+}
+
+func NewArangodbOperatorMembersConditionsInput(namespace string, name string, member string, condition string) ArangodbOperatorMembersConditionsInput {
+	return ArangodbOperatorMembersConditionsInput{
+		Namespace: namespace,
+		Name:      name,
+		Member:    member,
+		Condition: condition,
+	}
+}
+
+type ArangodbOperatorMembersConditionsInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+	Member    string `json:"member"`
+	Condition string `json:"condition"`
+}
+
+func (i ArangodbOperatorMembersConditionsInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorMembersConditionsGauge(value, i.Namespace, i.Name, i.Member, i.Condition)
+}
+
+func (i ArangodbOperatorMembersConditionsInput) Desc() metrics.Description {
+	return ArangodbOperatorMembersConditions()
+}
+
 func ArangodbOperatorMembersConditions() metrics.Description {
 	return arangodbOperatorMembersConditions
 }

pkg/generated/metric_descriptions/arangodb_operator_members_conditions_test.go

@@ -22,8 +22,153 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorMembersConditions_Descriptor(t *testing.T) {
 	ArangodbOperatorMembersConditions()
 }
+
+func Test_ArangodbOperatorMembersConditions_Factory(t *testing.T) {
+	global := NewArangodbOperatorMembersConditionsGaugeFactory()
+
+	object1 := ArangodbOperatorMembersConditionsInput{
+		Namespace: "1",
+		Name:      "1",
+		Member:    "1",
+		Condition: "1",
+	}
+
+	object2 := ArangodbOperatorMembersConditionsInput{
+		Namespace: "2",
+		Name:      "2",
+		Member:    "2",
+		Condition: "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorMembersConditions_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorMembersConditionsGaugeFactory()
+
+	object1 := ArangodbOperatorMembersConditionsInput{
+		Namespace: "1",
+		Name:      "1",
+		Member:    "1",
+		Condition: "1",
+	}
+
+	object2 := ArangodbOperatorMembersConditionsInput{
+		Namespace: "2",
+		Name:      "2",
+		Member:    "2",
+		Condition: "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_members_unexpected_container_exit_codes.go

@@ -32,6 +32,40 @@ func init() {
 	registerDescription(arangodbOperatorMembersUnexpectedContainerExitCodes)
 }
 
+func NewArangodbOperatorMembersUnexpectedContainerExitCodesCounterFactory() metrics.FactoryCounter[ArangodbOperatorMembersUnexpectedContainerExitCodesInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorMembersUnexpectedContainerExitCodesInput]()
+}
+
+func NewArangodbOperatorMembersUnexpectedContainerExitCodesInput(namespace string, name string, member string, container string, containerType string, code string, reason string) ArangodbOperatorMembersUnexpectedContainerExitCodesInput {
+	return ArangodbOperatorMembersUnexpectedContainerExitCodesInput{
+		Namespace:     namespace,
+		Name:          name,
+		Member:        member,
+		Container:     container,
+		ContainerType: containerType,
+		Code:          code,
+		Reason:        reason,
+	}
+}
+
+type ArangodbOperatorMembersUnexpectedContainerExitCodesInput struct {
+	Namespace     string `json:"namespace"`
+	Name          string `json:"name"`
+	Member        string `json:"member"`
+	Container     string `json:"container"`
+	ContainerType string `json:"containerType"`
+	Code          string `json:"code"`
+	Reason        string `json:"reason"`
+}
+
+func (i ArangodbOperatorMembersUnexpectedContainerExitCodesInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorMembersUnexpectedContainerExitCodesCounter(value, i.Namespace, i.Name, i.Member, i.Container, i.ContainerType, i.Code, i.Reason)
+}
+
+func (i ArangodbOperatorMembersUnexpectedContainerExitCodesInput) Desc() metrics.Description {
+	return ArangodbOperatorMembersUnexpectedContainerExitCodes()
+}
+
 func ArangodbOperatorMembersUnexpectedContainerExitCodes() metrics.Description {
 	return arangodbOperatorMembersUnexpectedContainerExitCodes
 }

pkg/generated/metric_descriptions/arangodb_operator_members_unexpected_container_exit_codes_test.go

@@ -22,8 +22,165 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorMembersUnexpectedContainerExitCodes_Descriptor(t *testing.T) {
 	ArangodbOperatorMembersUnexpectedContainerExitCodes()
 }
+
+func Test_ArangodbOperatorMembersUnexpectedContainerExitCodes_Factory(t *testing.T) {
+	global := NewArangodbOperatorMembersUnexpectedContainerExitCodesCounterFactory()
+
+	object1 := ArangodbOperatorMembersUnexpectedContainerExitCodesInput{
+		Namespace:     "1",
+		Name:          "1",
+		Member:        "1",
+		Container:     "1",
+		ContainerType: "1",
+		Code:          "1",
+		Reason:        "1",
+	}
+
+	object2 := ArangodbOperatorMembersUnexpectedContainerExitCodesInput{
+		Namespace:     "2",
+		Name:          "2",
+		Member:        "2",
+		Container:     "2",
+		ContainerType: "2",
+		Code:          "2",
+		Reason:        "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorMembersUnexpectedContainerExitCodes_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorMembersUnexpectedContainerExitCodesCounterFactory()
+
+	object1 := ArangodbOperatorMembersUnexpectedContainerExitCodesInput{
+		Namespace:     "1",
+		Name:          "1",
+		Member:        "1",
+		Container:     "1",
+		ContainerType: "1",
+		Code:          "1",
+		Reason:        "1",
+	}
+
+	object2 := ArangodbOperatorMembersUnexpectedContainerExitCodesInput{
+		Namespace:     "2",
+		Name:          "2",
+		Member:        "2",
+		Container:     "2",
+		ContainerType: "2",
+		Code:          "2",
+		Reason:        "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_objects_processed.go

@@ -0,0 +1,71 @@
+//
+// DISCLAIMER
+//
+// Copyright 2016-2024 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package metric_descriptions
+
+import (
+	"github.com/arangodb/kube-arangodb/pkg/util/metrics"
+)
+
+var (
+	arangodbOperatorObjectsProcessed = metrics.NewDescription("arangodb_operator_objects_processed", "Number of the processed objects", []string{`operator_name`}, nil)
+
+	// Global Fields
+	globalArangodbOperatorObjectsProcessedCounter = NewArangodbOperatorObjectsProcessedCounterFactory()
+)
+
+func init() {
+	registerDescription(arangodbOperatorObjectsProcessed)
+	registerCollector(globalArangodbOperatorObjectsProcessedCounter)
+}
+
+func GlobalArangodbOperatorObjectsProcessedCounter() metrics.FactoryCounter[ArangodbOperatorObjectsProcessedInput] {
+	return globalArangodbOperatorObjectsProcessedCounter
+}
+
+func NewArangodbOperatorObjectsProcessedCounterFactory() metrics.FactoryCounter[ArangodbOperatorObjectsProcessedInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorObjectsProcessedInput]()
+}
+
+func NewArangodbOperatorObjectsProcessedInput(operatorName string) ArangodbOperatorObjectsProcessedInput {
+	return ArangodbOperatorObjectsProcessedInput{
+		OperatorName: operatorName,
+	}
+}
+
+type ArangodbOperatorObjectsProcessedInput struct {
+	OperatorName string `json:"operatorName"`
+}
+
+func (i ArangodbOperatorObjectsProcessedInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorObjectsProcessedCounter(value, i.OperatorName)
+}
+
+func (i ArangodbOperatorObjectsProcessedInput) Desc() metrics.Description {
+	return ArangodbOperatorObjectsProcessed()
+}
+
+func ArangodbOperatorObjectsProcessed() metrics.Description {
+	return arangodbOperatorObjectsProcessed
+}
+
+func ArangodbOperatorObjectsProcessedCounter(value float64, operatorName string) metrics.Metric {
+	return ArangodbOperatorObjectsProcessed().Counter(value, operatorName)
+}

pkg/generated/metric_descriptions/arangodb_operator_objects_processed_test.go

@@ -26,18 +26,18 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func Test_ArangoOperatorObjectsProcessed_Descriptor(t *testing.T) {
-	ArangoOperatorObjectsProcessed()
+func Test_ArangodbOperatorObjectsProcessed_Descriptor(t *testing.T) {
+	ArangodbOperatorObjectsProcessed()
 }
 
-func Test_ArangoOperatorObjectsProcessed_Global(t *testing.T) {
-	global := GetArangoOperatorObjectsProcessedFactory()
+func Test_ArangodbOperatorObjectsProcessed_Factory(t *testing.T) {
+	global := NewArangodbOperatorObjectsProcessedCounterFactory()
 
-	object1 := ArangoOperatorObjectsProcessedItem{
+	object1 := ArangodbOperatorObjectsProcessedInput{
 		OperatorName: "1",
 	}
 
-	object2 := ArangoOperatorObjectsProcessedItem{
+	object2 := ArangodbOperatorObjectsProcessedInput{
 		OperatorName: "2",
 	}
 
@@ -51,7 +51,7 @@ func Test_ArangoOperatorObjectsProcessed_Global(t *testing.T) {
 	})
 
 	t.Run("Add", func(t *testing.T) {
-		global.Add(10, object1)
+		global.Add(object1, 10)
 
 		require.EqualValues(t, 10, global.Get(object1))
 		require.EqualValues(t, 0, global.Get(object2))
@@ -62,7 +62,7 @@ func Test_ArangoOperatorObjectsProcessed_Global(t *testing.T) {
 	})
 
 	t.Run("Add", func(t *testing.T) {
-		global.Add(3, object2)
+		global.Add(object2, 3)
 
 		require.EqualValues(t, 10, global.Get(object1))
 		require.EqualValues(t, 3, global.Get(object2))
@@ -73,7 +73,7 @@ func Test_ArangoOperatorObjectsProcessed_Global(t *testing.T) {
 	})
 
 	t.Run("Dec", func(t *testing.T) {
-		global.Add(-1, object1)
+		global.Add(object1, -1)
 
 		require.EqualValues(t, 9, global.Get(object1))
 		require.EqualValues(t, 3, global.Get(object2))
@@ -117,14 +117,14 @@ func Test_ArangoOperatorObjectsProcessed_Global(t *testing.T) {
 	})
 }
 
-func Test_ArangoOperatorObjectsProcessed_Global_Counter(t *testing.T) {
-	global := GetArangoOperatorObjectsProcessedFactory()
+func Test_ArangodbOperatorObjectsProcessed_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorObjectsProcessedCounterFactory()
 
-	object1 := ArangoOperatorObjectsProcessedItem{
+	object1 := ArangodbOperatorObjectsProcessedInput{
 		OperatorName: "1",
 	}
 
-	object2 := ArangoOperatorObjectsProcessedItem{
+	object2 := ArangodbOperatorObjectsProcessedInput{
 		OperatorName: "2",
 	}
 
@@ -138,7 +138,7 @@ func Test_ArangoOperatorObjectsProcessed_Global_Counter(t *testing.T) {
 	})
 
 	t.Run("Add", func(t *testing.T) {
-		global.Add(10, object1)
+		global.Add(object1, 10)
 
 		require.EqualValues(t, 10, global.Get(object1))
 		require.EqualValues(t, 0, global.Get(object2))

pkg/generated/metric_descriptions/arangodb_operator_rebalancer_enabled.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorRebalancerEnabled)
 }
 
+func NewArangodbOperatorRebalancerEnabledGaugeFactory() metrics.FactoryGauge[ArangodbOperatorRebalancerEnabledInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorRebalancerEnabledInput]()
+}
+
+func NewArangodbOperatorRebalancerEnabledInput(namespace string, name string) ArangodbOperatorRebalancerEnabledInput {
+	return ArangodbOperatorRebalancerEnabledInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorRebalancerEnabledInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorRebalancerEnabledInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorRebalancerEnabledGauge(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorRebalancerEnabledInput) Desc() metrics.Description {
+	return ArangodbOperatorRebalancerEnabled()
+}
+
 func ArangodbOperatorRebalancerEnabled() metrics.Description {
 	return arangodbOperatorRebalancerEnabled
 }

pkg/generated/metric_descriptions/arangodb_operator_rebalancer_enabled_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorRebalancerEnabled_Descriptor(t *testing.T) {
 	ArangodbOperatorRebalancerEnabled()
 }
+
+func Test_ArangodbOperatorRebalancerEnabled_Factory(t *testing.T) {
+	global := NewArangodbOperatorRebalancerEnabledGaugeFactory()
+
+	object1 := ArangodbOperatorRebalancerEnabledInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorRebalancerEnabledInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorRebalancerEnabled_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorRebalancerEnabledGaugeFactory()
+
+	object1 := ArangodbOperatorRebalancerEnabledInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorRebalancerEnabledInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_current.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorRebalancerMovesCurrent)
 }
 
+func NewArangodbOperatorRebalancerMovesCurrentGaugeFactory() metrics.FactoryGauge[ArangodbOperatorRebalancerMovesCurrentInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorRebalancerMovesCurrentInput]()
+}
+
+func NewArangodbOperatorRebalancerMovesCurrentInput(namespace string, name string) ArangodbOperatorRebalancerMovesCurrentInput {
+	return ArangodbOperatorRebalancerMovesCurrentInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorRebalancerMovesCurrentInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorRebalancerMovesCurrentInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorRebalancerMovesCurrentGauge(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorRebalancerMovesCurrentInput) Desc() metrics.Description {
+	return ArangodbOperatorRebalancerMovesCurrent()
+}
+
 func ArangodbOperatorRebalancerMovesCurrent() metrics.Description {
 	return arangodbOperatorRebalancerMovesCurrent
 }

pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_current_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorRebalancerMovesCurrent_Descriptor(t *testing.T) {
 	ArangodbOperatorRebalancerMovesCurrent()
 }
+
+func Test_ArangodbOperatorRebalancerMovesCurrent_Factory(t *testing.T) {
+	global := NewArangodbOperatorRebalancerMovesCurrentGaugeFactory()
+
+	object1 := ArangodbOperatorRebalancerMovesCurrentInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorRebalancerMovesCurrentInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorRebalancerMovesCurrent_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorRebalancerMovesCurrentGaugeFactory()
+
+	object1 := ArangodbOperatorRebalancerMovesCurrentInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorRebalancerMovesCurrentInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_failed.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorRebalancerMovesFailed)
 }
 
+func NewArangodbOperatorRebalancerMovesFailedCounterFactory() metrics.FactoryCounter[ArangodbOperatorRebalancerMovesFailedInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorRebalancerMovesFailedInput]()
+}
+
+func NewArangodbOperatorRebalancerMovesFailedInput(namespace string, name string) ArangodbOperatorRebalancerMovesFailedInput {
+	return ArangodbOperatorRebalancerMovesFailedInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorRebalancerMovesFailedInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorRebalancerMovesFailedInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorRebalancerMovesFailedCounter(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorRebalancerMovesFailedInput) Desc() metrics.Description {
+	return ArangodbOperatorRebalancerMovesFailed()
+}
+
 func ArangodbOperatorRebalancerMovesFailed() metrics.Description {
 	return arangodbOperatorRebalancerMovesFailed
 }

pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_failed_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorRebalancerMovesFailed_Descriptor(t *testing.T) {
 	ArangodbOperatorRebalancerMovesFailed()
 }
+
+func Test_ArangodbOperatorRebalancerMovesFailed_Factory(t *testing.T) {
+	global := NewArangodbOperatorRebalancerMovesFailedCounterFactory()
+
+	object1 := ArangodbOperatorRebalancerMovesFailedInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorRebalancerMovesFailedInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorRebalancerMovesFailed_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorRebalancerMovesFailedCounterFactory()
+
+	object1 := ArangodbOperatorRebalancerMovesFailedInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorRebalancerMovesFailedInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_generated.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorRebalancerMovesGenerated)
 }
 
+func NewArangodbOperatorRebalancerMovesGeneratedCounterFactory() metrics.FactoryCounter[ArangodbOperatorRebalancerMovesGeneratedInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorRebalancerMovesGeneratedInput]()
+}
+
+func NewArangodbOperatorRebalancerMovesGeneratedInput(namespace string, name string) ArangodbOperatorRebalancerMovesGeneratedInput {
+	return ArangodbOperatorRebalancerMovesGeneratedInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorRebalancerMovesGeneratedInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorRebalancerMovesGeneratedInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorRebalancerMovesGeneratedCounter(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorRebalancerMovesGeneratedInput) Desc() metrics.Description {
+	return ArangodbOperatorRebalancerMovesGenerated()
+}
+
 func ArangodbOperatorRebalancerMovesGenerated() metrics.Description {
 	return arangodbOperatorRebalancerMovesGenerated
 }

pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_generated_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorRebalancerMovesGenerated_Descriptor(t *testing.T) {
 	ArangodbOperatorRebalancerMovesGenerated()
 }
+
+func Test_ArangodbOperatorRebalancerMovesGenerated_Factory(t *testing.T) {
+	global := NewArangodbOperatorRebalancerMovesGeneratedCounterFactory()
+
+	object1 := ArangodbOperatorRebalancerMovesGeneratedInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorRebalancerMovesGeneratedInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorRebalancerMovesGenerated_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorRebalancerMovesGeneratedCounterFactory()
+
+	object1 := ArangodbOperatorRebalancerMovesGeneratedInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorRebalancerMovesGeneratedInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_succeeded.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorRebalancerMovesSucceeded)
 }
 
+func NewArangodbOperatorRebalancerMovesSucceededCounterFactory() metrics.FactoryCounter[ArangodbOperatorRebalancerMovesSucceededInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorRebalancerMovesSucceededInput]()
+}
+
+func NewArangodbOperatorRebalancerMovesSucceededInput(namespace string, name string) ArangodbOperatorRebalancerMovesSucceededInput {
+	return ArangodbOperatorRebalancerMovesSucceededInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorRebalancerMovesSucceededInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorRebalancerMovesSucceededInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorRebalancerMovesSucceededCounter(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorRebalancerMovesSucceededInput) Desc() metrics.Description {
+	return ArangodbOperatorRebalancerMovesSucceeded()
+}
+
 func ArangodbOperatorRebalancerMovesSucceeded() metrics.Description {
 	return arangodbOperatorRebalancerMovesSucceeded
 }

pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_succeeded_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorRebalancerMovesSucceeded_Descriptor(t *testing.T) {
 	ArangodbOperatorRebalancerMovesSucceeded()
 }
+
+func Test_ArangodbOperatorRebalancerMovesSucceeded_Factory(t *testing.T) {
+	global := NewArangodbOperatorRebalancerMovesSucceededCounterFactory()
+
+	object1 := ArangodbOperatorRebalancerMovesSucceededInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorRebalancerMovesSucceededInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorRebalancerMovesSucceeded_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorRebalancerMovesSucceededCounterFactory()
+
+	object1 := ArangodbOperatorRebalancerMovesSucceededInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorRebalancerMovesSucceededInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_accepted.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorResourcesArangodeploymentAccepted)
 }
 
+func NewArangodbOperatorResourcesArangodeploymentAcceptedGaugeFactory() metrics.FactoryGauge[ArangodbOperatorResourcesArangodeploymentAcceptedInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorResourcesArangodeploymentAcceptedInput]()
+}
+
+func NewArangodbOperatorResourcesArangodeploymentAcceptedInput(namespace string, name string) ArangodbOperatorResourcesArangodeploymentAcceptedInput {
+	return ArangodbOperatorResourcesArangodeploymentAcceptedInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorResourcesArangodeploymentAcceptedInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentAcceptedInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorResourcesArangodeploymentAcceptedGauge(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentAcceptedInput) Desc() metrics.Description {
+	return ArangodbOperatorResourcesArangodeploymentAccepted()
+}
+
 func ArangodbOperatorResourcesArangodeploymentAccepted() metrics.Description {
 	return arangodbOperatorResourcesArangodeploymentAccepted
 }

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_accepted_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorResourcesArangodeploymentAccepted_Descriptor(t *testing.T) {
 	ArangodbOperatorResourcesArangodeploymentAccepted()
 }
+
+func Test_ArangodbOperatorResourcesArangodeploymentAccepted_Factory(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentAcceptedGaugeFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentAcceptedInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentAcceptedInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorResourcesArangodeploymentAccepted_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentAcceptedGaugeFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentAcceptedInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentAcceptedInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_immutable_errors.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorResourcesArangodeploymentImmutableErrors)
 }
 
+func NewArangodbOperatorResourcesArangodeploymentImmutableErrorsCounterFactory() metrics.FactoryCounter[ArangodbOperatorResourcesArangodeploymentImmutableErrorsInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorResourcesArangodeploymentImmutableErrorsInput]()
+}
+
+func NewArangodbOperatorResourcesArangodeploymentImmutableErrorsInput(namespace string, name string) ArangodbOperatorResourcesArangodeploymentImmutableErrorsInput {
+	return ArangodbOperatorResourcesArangodeploymentImmutableErrorsInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorResourcesArangodeploymentImmutableErrorsInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentImmutableErrorsInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorResourcesArangodeploymentImmutableErrorsCounter(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentImmutableErrorsInput) Desc() metrics.Description {
+	return ArangodbOperatorResourcesArangodeploymentImmutableErrors()
+}
+
 func ArangodbOperatorResourcesArangodeploymentImmutableErrors() metrics.Description {
 	return arangodbOperatorResourcesArangodeploymentImmutableErrors
 }

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_immutable_errors_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorResourcesArangodeploymentImmutableErrors_Descriptor(t *testing.T) {
 	ArangodbOperatorResourcesArangodeploymentImmutableErrors()
 }
+
+func Test_ArangodbOperatorResourcesArangodeploymentImmutableErrors_Factory(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentImmutableErrorsCounterFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentImmutableErrorsInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentImmutableErrorsInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorResourcesArangodeploymentImmutableErrors_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentImmutableErrorsCounterFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentImmutableErrorsInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentImmutableErrorsInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_propagated.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorResourcesArangodeploymentPropagated)
 }
 
+func NewArangodbOperatorResourcesArangodeploymentPropagatedGaugeFactory() metrics.FactoryGauge[ArangodbOperatorResourcesArangodeploymentPropagatedInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorResourcesArangodeploymentPropagatedInput]()
+}
+
+func NewArangodbOperatorResourcesArangodeploymentPropagatedInput(namespace string, name string) ArangodbOperatorResourcesArangodeploymentPropagatedInput {
+	return ArangodbOperatorResourcesArangodeploymentPropagatedInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorResourcesArangodeploymentPropagatedInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentPropagatedInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorResourcesArangodeploymentPropagatedGauge(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentPropagatedInput) Desc() metrics.Description {
+	return ArangodbOperatorResourcesArangodeploymentPropagated()
+}
+
 func ArangodbOperatorResourcesArangodeploymentPropagated() metrics.Description {
 	return arangodbOperatorResourcesArangodeploymentPropagated
 }

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_propagated_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorResourcesArangodeploymentPropagated_Descriptor(t *testing.T) {
 	ArangodbOperatorResourcesArangodeploymentPropagated()
 }
+
+func Test_ArangodbOperatorResourcesArangodeploymentPropagated_Factory(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentPropagatedGaugeFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentPropagatedInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentPropagatedInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorResourcesArangodeploymentPropagated_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentPropagatedGaugeFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentPropagatedInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentPropagatedInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_status_restores.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorResourcesArangodeploymentStatusRestores)
 }
 
+func NewArangodbOperatorResourcesArangodeploymentStatusRestoresCounterFactory() metrics.FactoryCounter[ArangodbOperatorResourcesArangodeploymentStatusRestoresInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorResourcesArangodeploymentStatusRestoresInput]()
+}
+
+func NewArangodbOperatorResourcesArangodeploymentStatusRestoresInput(namespace string, name string) ArangodbOperatorResourcesArangodeploymentStatusRestoresInput {
+	return ArangodbOperatorResourcesArangodeploymentStatusRestoresInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorResourcesArangodeploymentStatusRestoresInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentStatusRestoresInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorResourcesArangodeploymentStatusRestoresCounter(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentStatusRestoresInput) Desc() metrics.Description {
+	return ArangodbOperatorResourcesArangodeploymentStatusRestores()
+}
+
 func ArangodbOperatorResourcesArangodeploymentStatusRestores() metrics.Description {
 	return arangodbOperatorResourcesArangodeploymentStatusRestores
 }

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_status_restores_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorResourcesArangodeploymentStatusRestores_Descriptor(t *testing.T) {
 	ArangodbOperatorResourcesArangodeploymentStatusRestores()
 }
+
+func Test_ArangodbOperatorResourcesArangodeploymentStatusRestores_Factory(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentStatusRestoresCounterFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentStatusRestoresInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentStatusRestoresInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorResourcesArangodeploymentStatusRestores_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentStatusRestoresCounterFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentStatusRestoresInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentStatusRestoresInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_uptodate.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorResourcesArangodeploymentUptodate)
 }
 
+func NewArangodbOperatorResourcesArangodeploymentUptodateGaugeFactory() metrics.FactoryGauge[ArangodbOperatorResourcesArangodeploymentUptodateInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorResourcesArangodeploymentUptodateInput]()
+}
+
+func NewArangodbOperatorResourcesArangodeploymentUptodateInput(namespace string, name string) ArangodbOperatorResourcesArangodeploymentUptodateInput {
+	return ArangodbOperatorResourcesArangodeploymentUptodateInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorResourcesArangodeploymentUptodateInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentUptodateInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorResourcesArangodeploymentUptodateGauge(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentUptodateInput) Desc() metrics.Description {
+	return ArangodbOperatorResourcesArangodeploymentUptodate()
+}
+
 func ArangodbOperatorResourcesArangodeploymentUptodate() metrics.Description {
 	return arangodbOperatorResourcesArangodeploymentUptodate
 }

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_uptodate_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorResourcesArangodeploymentUptodate_Descriptor(t *testing.T) {
 	ArangodbOperatorResourcesArangodeploymentUptodate()
 }
+
+func Test_ArangodbOperatorResourcesArangodeploymentUptodate_Factory(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentUptodateGaugeFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentUptodateInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentUptodateInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorResourcesArangodeploymentUptodate_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentUptodateGaugeFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentUptodateInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentUptodateInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_validation_errors.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorResourcesArangodeploymentValidationErrors)
 }
 
+func NewArangodbOperatorResourcesArangodeploymentValidationErrorsCounterFactory() metrics.FactoryCounter[ArangodbOperatorResourcesArangodeploymentValidationErrorsInput] {
+	return metrics.NewFactoryCounter[ArangodbOperatorResourcesArangodeploymentValidationErrorsInput]()
+}
+
+func NewArangodbOperatorResourcesArangodeploymentValidationErrorsInput(namespace string, name string) ArangodbOperatorResourcesArangodeploymentValidationErrorsInput {
+	return ArangodbOperatorResourcesArangodeploymentValidationErrorsInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorResourcesArangodeploymentValidationErrorsInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentValidationErrorsInput) Counter(value float64) metrics.Metric {
+	return ArangodbOperatorResourcesArangodeploymentValidationErrorsCounter(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentValidationErrorsInput) Desc() metrics.Description {
+	return ArangodbOperatorResourcesArangodeploymentValidationErrors()
+}
+
 func ArangodbOperatorResourcesArangodeploymentValidationErrors() metrics.Description {
 	return arangodbOperatorResourcesArangodeploymentValidationErrors
 }

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_validation_errors_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorResourcesArangodeploymentValidationErrors_Descriptor(t *testing.T) {
 	ArangodbOperatorResourcesArangodeploymentValidationErrors()
 }
+
+func Test_ArangodbOperatorResourcesArangodeploymentValidationErrors_Factory(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentValidationErrorsCounterFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentValidationErrorsInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentValidationErrorsInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorResourcesArangodeploymentValidationErrors_Factory_Counter(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentValidationErrorsCounterFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentValidationErrorsInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentValidationErrorsInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_active.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorResourcesArangodeploymentreplicationActive)
 }
 
+func NewArangodbOperatorResourcesArangodeploymentreplicationActiveGaugeFactory() metrics.FactoryGauge[ArangodbOperatorResourcesArangodeploymentreplicationActiveInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorResourcesArangodeploymentreplicationActiveInput]()
+}
+
+func NewArangodbOperatorResourcesArangodeploymentreplicationActiveInput(namespace string, name string) ArangodbOperatorResourcesArangodeploymentreplicationActiveInput {
+	return ArangodbOperatorResourcesArangodeploymentreplicationActiveInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorResourcesArangodeploymentreplicationActiveInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentreplicationActiveInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorResourcesArangodeploymentreplicationActiveGauge(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentreplicationActiveInput) Desc() metrics.Description {
+	return ArangodbOperatorResourcesArangodeploymentreplicationActive()
+}
+
 func ArangodbOperatorResourcesArangodeploymentreplicationActive() metrics.Description {
 	return arangodbOperatorResourcesArangodeploymentreplicationActive
 }

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_active_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorResourcesArangodeploymentreplicationActive_Descriptor(t *testing.T) {
 	ArangodbOperatorResourcesArangodeploymentreplicationActive()
 }
+
+func Test_ArangodbOperatorResourcesArangodeploymentreplicationActive_Factory(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentreplicationActiveGaugeFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentreplicationActiveInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentreplicationActiveInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorResourcesArangodeploymentreplicationActive_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentreplicationActiveGaugeFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentreplicationActiveInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentreplicationActiveInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_failed.go

@@ -32,6 +32,30 @@ func init() {
 	registerDescription(arangodbOperatorResourcesArangodeploymentreplicationFailed)
 }
 
+func NewArangodbOperatorResourcesArangodeploymentreplicationFailedGaugeFactory() metrics.FactoryGauge[ArangodbOperatorResourcesArangodeploymentreplicationFailedInput] {
+	return metrics.NewFactoryGauge[ArangodbOperatorResourcesArangodeploymentreplicationFailedInput]()
+}
+
+func NewArangodbOperatorResourcesArangodeploymentreplicationFailedInput(namespace string, name string) ArangodbOperatorResourcesArangodeploymentreplicationFailedInput {
+	return ArangodbOperatorResourcesArangodeploymentreplicationFailedInput{
+		Namespace: namespace,
+		Name:      name,
+	}
+}
+
+type ArangodbOperatorResourcesArangodeploymentreplicationFailedInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentreplicationFailedInput) Gauge(value float64) metrics.Metric {
+	return ArangodbOperatorResourcesArangodeploymentreplicationFailedGauge(value, i.Namespace, i.Name)
+}
+
+func (i ArangodbOperatorResourcesArangodeploymentreplicationFailedInput) Desc() metrics.Description {
+	return ArangodbOperatorResourcesArangodeploymentreplicationFailed()
+}
+
 func ArangodbOperatorResourcesArangodeploymentreplicationFailed() metrics.Description {
 	return arangodbOperatorResourcesArangodeploymentreplicationFailed
 }

pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_failed_test.go

@@ -22,8 +22,145 @@ package metric_descriptions
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_ArangodbOperatorResourcesArangodeploymentreplicationFailed_Descriptor(t *testing.T) {
 	ArangodbOperatorResourcesArangodeploymentreplicationFailed()
 }
+
+func Test_ArangodbOperatorResourcesArangodeploymentreplicationFailed_Factory(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentreplicationFailedGaugeFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentreplicationFailedInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentreplicationFailedInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbOperatorResourcesArangodeploymentreplicationFailed_Factory_Gauge(t *testing.T) {
+	global := NewArangodbOperatorResourcesArangodeploymentreplicationFailedGaugeFactory()
+
+	object1 := ArangodbOperatorResourcesArangodeploymentreplicationFailedInput{
+		Namespace: "1",
+		Name:      "1",
+	}
+
+	object2 := ArangodbOperatorResourcesArangodeploymentreplicationFailedInput{
+		Namespace: "2",
+		Name:      "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_duration.go

@@ -0,0 +1,71 @@
+//
+// DISCLAIMER
+//
+// Copyright 2016-2024 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package metric_descriptions
+
+import (
+	"github.com/arangodb/kube-arangodb/pkg/util/metrics"
+)
+
+var (
+	arangodbResourcesDeploymentConfigMapDuration = metrics.NewDescription("arangodb_resources_deployment_config_map_duration", "Duration of inspected ConfigMaps by Deployment in seconds", []string{`deployment`}, nil)
+
+	// Global Fields
+	globalArangodbResourcesDeploymentConfigMapDurationGauge = NewArangodbResourcesDeploymentConfigMapDurationGaugeFactory()
+)
+
+func init() {
+	registerDescription(arangodbResourcesDeploymentConfigMapDuration)
+	registerCollector(globalArangodbResourcesDeploymentConfigMapDurationGauge)
+}
+
+func GlobalArangodbResourcesDeploymentConfigMapDurationGauge() metrics.FactoryGauge[ArangodbResourcesDeploymentConfigMapDurationInput] {
+	return globalArangodbResourcesDeploymentConfigMapDurationGauge
+}
+
+func NewArangodbResourcesDeploymentConfigMapDurationGaugeFactory() metrics.FactoryGauge[ArangodbResourcesDeploymentConfigMapDurationInput] {
+	return metrics.NewFactoryGauge[ArangodbResourcesDeploymentConfigMapDurationInput]()
+}
+
+func NewArangodbResourcesDeploymentConfigMapDurationInput(deployment string) ArangodbResourcesDeploymentConfigMapDurationInput {
+	return ArangodbResourcesDeploymentConfigMapDurationInput{
+		Deployment: deployment,
+	}
+}
+
+type ArangodbResourcesDeploymentConfigMapDurationInput struct {
+	Deployment string `json:"deployment"`
+}
+
+func (i ArangodbResourcesDeploymentConfigMapDurationInput) Gauge(value float64) metrics.Metric {
+	return ArangodbResourcesDeploymentConfigMapDurationGauge(value, i.Deployment)
+}
+
+func (i ArangodbResourcesDeploymentConfigMapDurationInput) Desc() metrics.Description {
+	return ArangodbResourcesDeploymentConfigMapDuration()
+}
+
+func ArangodbResourcesDeploymentConfigMapDuration() metrics.Description {
+	return arangodbResourcesDeploymentConfigMapDuration
+}
+
+func ArangodbResourcesDeploymentConfigMapDurationGauge(value float64, deployment string) metrics.Metric {
+	return ArangodbResourcesDeploymentConfigMapDuration().Gauge(value, deployment)
+}

pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_duration_test.go

@@ -0,0 +1,162 @@
+//
+// DISCLAIMER
+//
+// Copyright 2016-2024 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package metric_descriptions
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func Test_ArangodbResourcesDeploymentConfigMapDuration_Descriptor(t *testing.T) {
+	ArangodbResourcesDeploymentConfigMapDuration()
+}
+
+func Test_ArangodbResourcesDeploymentConfigMapDuration_Factory(t *testing.T) {
+	global := NewArangodbResourcesDeploymentConfigMapDurationGaugeFactory()
+
+	object1 := ArangodbResourcesDeploymentConfigMapDurationInput{
+		Deployment: "1",
+	}
+
+	object2 := ArangodbResourcesDeploymentConfigMapDurationInput{
+		Deployment: "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbResourcesDeploymentConfigMapDuration_Factory_Gauge(t *testing.T) {
+	global := NewArangodbResourcesDeploymentConfigMapDurationGaugeFactory()
+
+	object1 := ArangodbResourcesDeploymentConfigMapDurationInput{
+		Deployment: "1",
+	}
+
+	object2 := ArangodbResourcesDeploymentConfigMapDurationInput{
+		Deployment: "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		global.Set(object1, 3)
+		global.Set(object2, 1)
+
+		require.EqualValues(t, 3, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_inspected.go

@@ -0,0 +1,71 @@
+//
+// DISCLAIMER
+//
+// Copyright 2016-2024 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package metric_descriptions
+
+import (
+	"github.com/arangodb/kube-arangodb/pkg/util/metrics"
+)
+
+var (
+	arangodbResourcesDeploymentConfigMapInspected = metrics.NewDescription("arangodb_resources_deployment_config_map_inspected", "Number of inspected ConfigMaps by Deployment", []string{`deployment`}, nil)
+
+	// Global Fields
+	globalArangodbResourcesDeploymentConfigMapInspectedCounter = NewArangodbResourcesDeploymentConfigMapInspectedCounterFactory()
+)
+
+func init() {
+	registerDescription(arangodbResourcesDeploymentConfigMapInspected)
+	registerCollector(globalArangodbResourcesDeploymentConfigMapInspectedCounter)
+}
+
+func GlobalArangodbResourcesDeploymentConfigMapInspectedCounter() metrics.FactoryCounter[ArangodbResourcesDeploymentConfigMapInspectedInput] {
+	return globalArangodbResourcesDeploymentConfigMapInspectedCounter
+}
+
+func NewArangodbResourcesDeploymentConfigMapInspectedCounterFactory() metrics.FactoryCounter[ArangodbResourcesDeploymentConfigMapInspectedInput] {
+	return metrics.NewFactoryCounter[ArangodbResourcesDeploymentConfigMapInspectedInput]()
+}
+
+func NewArangodbResourcesDeploymentConfigMapInspectedInput(deployment string) ArangodbResourcesDeploymentConfigMapInspectedInput {
+	return ArangodbResourcesDeploymentConfigMapInspectedInput{
+		Deployment: deployment,
+	}
+}
+
+type ArangodbResourcesDeploymentConfigMapInspectedInput struct {
+	Deployment string `json:"deployment"`
+}
+
+func (i ArangodbResourcesDeploymentConfigMapInspectedInput) Counter(value float64) metrics.Metric {
+	return ArangodbResourcesDeploymentConfigMapInspectedCounter(value, i.Deployment)
+}
+
+func (i ArangodbResourcesDeploymentConfigMapInspectedInput) Desc() metrics.Description {
+	return ArangodbResourcesDeploymentConfigMapInspected()
+}
+
+func ArangodbResourcesDeploymentConfigMapInspected() metrics.Description {
+	return arangodbResourcesDeploymentConfigMapInspected
+}
+
+func ArangodbResourcesDeploymentConfigMapInspectedCounter(value float64, deployment string) metrics.Metric {
+	return ArangodbResourcesDeploymentConfigMapInspected().Counter(value, deployment)
+}

pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_inspected_test.go

@@ -0,0 +1,162 @@
+//
+// DISCLAIMER
+//
+// Copyright 2016-2024 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package metric_descriptions
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func Test_ArangodbResourcesDeploymentConfigMapInspected_Descriptor(t *testing.T) {
+	ArangodbResourcesDeploymentConfigMapInspected()
+}
+
+func Test_ArangodbResourcesDeploymentConfigMapInspected_Factory(t *testing.T) {
+	global := NewArangodbResourcesDeploymentConfigMapInspectedCounterFactory()
+
+	object1 := ArangodbResourcesDeploymentConfigMapInspectedInput{
+		Deployment: "1",
+	}
+
+	object2 := ArangodbResourcesDeploymentConfigMapInspectedInput{
+		Deployment: "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object2, 3)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Dec", func(t *testing.T) {
+		global.Add(object1, -1)
+
+		require.EqualValues(t, 9, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object1)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 3, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Remove", func(t *testing.T) {
+		global.Remove(object2)
+
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+}
+
+func Test_ArangodbResourcesDeploymentConfigMapInspected_Factory_Counter(t *testing.T) {
+	global := NewArangodbResourcesDeploymentConfigMapInspectedCounterFactory()
+
+	object1 := ArangodbResourcesDeploymentConfigMapInspectedInput{
+		Deployment: "1",
+	}
+
+	object2 := ArangodbResourcesDeploymentConfigMapInspectedInput{
+		Deployment: "2",
+	}
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 0)
+	})
+
+	t.Run("Precheck", func(t *testing.T) {
+		require.EqualValues(t, 0, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("Add", func(t *testing.T) {
+		global.Add(object1, 10)
+
+		require.EqualValues(t, 10, global.Get(object1))
+		require.EqualValues(t, 0, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 1)
+	})
+
+	t.Run("Inc", func(t *testing.T) {
+		global.Inc(object1)
+		global.Inc(object2)
+
+		require.EqualValues(t, 11, global.Get(object1))
+		require.EqualValues(t, 1, global.Get(object2))
+	})
+
+	t.Run("List", func(t *testing.T) {
+		require.Len(t, global.Items(), 2)
+	})
+}

pkg/operatorV2/operator_worker.go

@@ -102,7 +102,7 @@ func (o *operator) processObject(obj interface{}) error {
 		return nil
 	}
 
-	metric_descriptions.ArangoOperatorObjectsProcessedInc(o.operator.name)
+	metric_descriptions.GlobalArangodbOperatorObjectsProcessedCounter().Inc(metric_descriptions.NewArangodbOperatorObjectsProcessedInput(o.operator.name))
 
 	loggerWorker.Trace("Received Item Action: %s, Type: %s/%s/%s, Namespace: %s, Name: %s",
 		item.Operation,

pkg/util/metrics/duration.go

@@ -0,0 +1,30 @@
+//
+// DISCLAIMER
+//
+// Copyright 2024 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package metrics
+
+import "time"
+
+func WithDuration[T FactoryTypeGauge](f FactoryGauge[T], v T) func() {
+	start := time.Now()
+	return func() {
+		f.Add(v, float64(time.Since(start))/float64(time.Second))
+	}
+}

pkg/util/metrics/factory_counter.go

@@ -0,0 +1,109 @@
+//
+// DISCLAIMER
+//
+// Copyright 2024 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package metrics
+
+import (
+	"sync"
+
+	"github.com/arangodb/kube-arangodb/pkg/util"
+)
+
+type FactoryTypeCounter interface {
+	comparable
+
+	Desc() Description
+	Counter(value float64) Metric
+}
+
+func NewFactoryCounter[T FactoryTypeCounter]() FactoryCounter[T] {
+	return &factoryCounter[T]{
+		desc:    util.Default[T]().Desc(),
+		metrics: map[T]float64{},
+	}
+}
+
+type FactoryCounter[T FactoryTypeCounter] interface {
+	Collector
+
+	Items() []T
+	Get(v T) float64
+	Remove(v T)
+	Add(v T, value float64)
+	Inc(v T)
+}
+
+type factoryCounter[T FactoryTypeCounter] struct {
+	lock sync.Mutex
+
+	desc    Description
+	metrics map[T]float64
+}
+
+func (f *factoryCounter[T]) CollectMetrics(in PushMetric) {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	for k, v := range f.metrics {
+		in.Push(k.Counter(v))
+	}
+}
+
+func (f *factoryCounter[T]) CollectDescriptions(in PushDescription) {
+	in.Push(f.desc)
+}
+
+func (f *factoryCounter[T]) Items() []T {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	r := make([]T, 0, len(f.metrics))
+
+	for k := range f.metrics {
+		r = append(r, k)
+	}
+
+	return r
+}
+
+func (f *factoryCounter[T]) Get(v T) float64 {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	return f.metrics[v]
+}
+
+func (f *factoryCounter[T]) Remove(v T) {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	delete(f.metrics, v)
+}
+
+func (f *factoryCounter[T]) Add(v T, value float64) {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	f.metrics[v] = value + f.metrics[v]
+}
+
+func (f *factoryCounter[T]) Inc(v T) {
+	f.Add(v, 1)
+}

pkg/util/metrics/factory_gauge.go

@@ -0,0 +1,112 @@
+//
+// DISCLAIMER
+//
+// Copyright 2024 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package metrics
+
+import (
+	"sync"
+
+	"github.com/arangodb/kube-arangodb/pkg/util"
+)
+
+type FactoryTypeGauge interface {
+	comparable
+
+	Desc() Description
+	Gauge(value float64) Metric
+}
+
+func NewFactoryGauge[T FactoryTypeGauge]() FactoryGauge[T] {
+	return &factoryGauge[T]{
+		desc:    util.Default[T]().Desc(),
+		metrics: map[T]float64{},
+	}
+}
+
+type FactoryGauge[T FactoryTypeGauge] interface {
+	Collector
+
+	Items() []T
+	Get(v T) float64
+	Remove(v T)
+	Set(v T, value float64)
+	Add(v T, value float64)
+}
+
+type factoryGauge[T FactoryTypeGauge] struct {
+	lock sync.Mutex
+
+	desc    Description
+	metrics map[T]float64
+}
+
+func (f *factoryGauge[T]) CollectMetrics(in PushMetric) {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	for k, v := range f.metrics {
+		in.Push(k.Gauge(v))
+	}
+}
+
+func (f *factoryGauge[T]) CollectDescriptions(in PushDescription) {
+	in.Push(f.desc)
+}
+
+func (f *factoryGauge[T]) Items() []T {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	r := make([]T, 0, len(f.metrics))
+
+	for k := range f.metrics {
+		r = append(r, k)
+	}
+
+	return r
+}
+
+func (f *factoryGauge[T]) Get(v T) float64 {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	return f.metrics[v]
+}
+
+func (f *factoryGauge[T]) Remove(v T) {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	delete(f.metrics, v)
+}
+
+func (f *factoryGauge[T]) Set(v T, value float64) {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	f.metrics[v] = value
+}
+
+func (f *factoryGauge[T]) Add(v T, value float64) {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	f.metrics[v] = value + f.metrics[v]
+}