From bda998564bce563fd5a6b5abcb071214a73b6368 Mon Sep 17 00:00:00 2001 From: Adam Janikowski <12255597+ajanikow@users.noreply.github.com> Date: Thu, 19 Sep 2024 11:04:06 +0200 Subject: [PATCH] [Improvement] Improve metric handling (#1728) --- CHANGELOG.md | 1 + docs/generated/metrics/README.md | 70 +++---- .../arangodb_operator_objects_processed.md | 17 ++ ...esources_deployment_config_map_duration.md | 17 ++ ...sources_deployment_config_map_inspected.md | 17 ++ internal/metrics.go | 2 +- internal/metrics.item.go.tmpl | 171 ++++-------------- internal/metrics.item.go_test.tmpl | 77 ++++++-- internal/metrics.yaml | 21 ++- pkg/deployment/resources/config_maps.go | 15 +- .../arango_operator_objects_processed.go | 149 --------------- ...db_operator_agency_cache_health_present.go | 24 +++ ...erator_agency_cache_health_present_test.go | 137 ++++++++++++++ .../arangodb_operator_agency_cache_healthy.go | 24 +++ ...godb_operator_agency_cache_healthy_test.go | 137 ++++++++++++++ .../arangodb_operator_agency_cache_leaders.go | 26 +++ ...godb_operator_agency_cache_leaders_test.go | 141 +++++++++++++++ ...rator_agency_cache_member_commit_offset.go | 26 +++ ..._agency_cache_member_commit_offset_test.go | 141 +++++++++++++++ ...db_operator_agency_cache_member_serving.go | 26 +++ ...erator_agency_cache_member_serving_test.go | 141 +++++++++++++++ .../arangodb_operator_agency_cache_present.go | 24 +++ ...godb_operator_agency_cache_present_test.go | 137 ++++++++++++++ .../arangodb_operator_agency_cache_serving.go | 24 +++ ...godb_operator_agency_cache_serving_test.go | 137 ++++++++++++++ .../arangodb_operator_agency_errors.go | 24 +++ .../arangodb_operator_agency_errors_test.go | 137 ++++++++++++++ .../arangodb_operator_agency_fetches.go | 24 +++ .../arangodb_operator_agency_fetches_test.go | 137 ++++++++++++++ .../arangodb_operator_agency_index.go | 24 +++ .../arangodb_operator_agency_index_test.go | 137 ++++++++++++++ ...arangodb_operator_deployment_conditions.go | 26 +++ ...odb_operator_deployment_conditions_test.go | 141 +++++++++++++++ .../arangodb_operator_engine_assertions.go | 22 +++ ...rangodb_operator_engine_assertions_test.go | 133 ++++++++++++++ .../arangodb_operator_engine_ops_alerts.go | 24 +++ ...rangodb_operator_engine_ops_alerts_test.go | 137 ++++++++++++++ ...angodb_operator_engine_panics_recovered.go | 22 +++ ...b_operator_engine_panics_recovered_test.go | 133 ++++++++++++++ ...erator_kubernetes_client_request_errors.go | 24 +++ ...r_kubernetes_client_request_errors_test.go | 137 ++++++++++++++ ...odb_operator_kubernetes_client_requests.go | 24 +++ ...perator_kubernetes_client_requests_test.go | 137 ++++++++++++++ .../arangodb_operator_members_conditions.go | 28 +++ ...angodb_operator_members_conditions_test.go | 145 +++++++++++++++ ...members_unexpected_container_exit_codes.go | 34 ++++ ...rs_unexpected_container_exit_codes_test.go | 157 ++++++++++++++++ .../arangodb_operator_objects_processed.go | 71 ++++++++ ...angodb_operator_objects_processed_test.go} | 28 +-- .../arangodb_operator_rebalancer_enabled.go | 24 +++ ...angodb_operator_rebalancer_enabled_test.go | 137 ++++++++++++++ ...ngodb_operator_rebalancer_moves_current.go | 24 +++ ..._operator_rebalancer_moves_current_test.go | 137 ++++++++++++++ ...angodb_operator_rebalancer_moves_failed.go | 24 +++ ...b_operator_rebalancer_moves_failed_test.go | 137 ++++++++++++++ ...odb_operator_rebalancer_moves_generated.go | 24 +++ ...perator_rebalancer_moves_generated_test.go | 137 ++++++++++++++ ...odb_operator_rebalancer_moves_succeeded.go | 24 +++ ...perator_rebalancer_moves_succeeded_test.go | 137 ++++++++++++++ ...tor_resources_arangodeployment_accepted.go | 24 +++ ...esources_arangodeployment_accepted_test.go | 137 ++++++++++++++ ...urces_arangodeployment_immutable_errors.go | 24 +++ ..._arangodeployment_immutable_errors_test.go | 137 ++++++++++++++ ...r_resources_arangodeployment_propagated.go | 24 +++ ...ources_arangodeployment_propagated_test.go | 137 ++++++++++++++ ...ources_arangodeployment_status_restores.go | 24 +++ ...s_arangodeployment_status_restores_test.go | 137 ++++++++++++++ ...tor_resources_arangodeployment_uptodate.go | 24 +++ ...esources_arangodeployment_uptodate_test.go | 137 ++++++++++++++ ...rces_arangodeployment_validation_errors.go | 24 +++ ...arangodeployment_validation_errors_test.go | 137 ++++++++++++++ ...rces_arangodeploymentreplication_active.go | 24 +++ ...arangodeploymentreplication_active_test.go | 137 ++++++++++++++ ...rces_arangodeploymentreplication_failed.go | 24 +++ ...arangodeploymentreplication_failed_test.go | 137 ++++++++++++++ ...esources_deployment_config_map_duration.go | 71 ++++++++ ...ces_deployment_config_map_duration_test.go | 162 +++++++++++++++++ ...sources_deployment_config_map_inspected.go | 71 ++++++++ ...es_deployment_config_map_inspected_test.go | 162 +++++++++++++++++ pkg/operatorV2/operator_worker.go | 2 +- pkg/util/metrics/duration.go | 30 +++ pkg/util/metrics/factory_counter.go | 109 +++++++++++ pkg/util/metrics/factory_gauge.go | 112 ++++++++++++ 83 files changed, 6060 insertions(+), 360 deletions(-) create mode 100644 docs/generated/metrics/arangodb_operator_objects_processed.md create mode 100644 docs/generated/metrics/arangodb_resources_deployment_config_map_duration.md create mode 100644 docs/generated/metrics/arangodb_resources_deployment_config_map_inspected.md delete mode 100644 pkg/generated/metric_descriptions/arango_operator_objects_processed.go create mode 100644 pkg/generated/metric_descriptions/arangodb_operator_objects_processed.go rename pkg/generated/metric_descriptions/{arango_operator_objects_processed_test.go => arangodb_operator_objects_processed_test.go} (82%) create mode 100644 pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_duration.go create mode 100644 pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_duration_test.go create mode 100644 pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_inspected.go create mode 100644 pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_inspected_test.go create mode 100644 pkg/util/metrics/duration.go create mode 100644 pkg/util/metrics/factory_counter.go create mode 100644 pkg/util/metrics/factory_gauge.go diff --git a/CHANGELOG.md b/CHANGELOG.md index b0fbe048c..df03d648f 100644 --- a/CHANGELOG.md +++ b/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 diff --git a/docs/generated/metrics/README.md b/docs/generated/metrics/README.md index 1b7551643..f432feeec 100644 --- a/docs/generated/metrics/README.md +++ b/docs/generated/metrics/README.md @@ -12,39 +12,41 @@ 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 | -| [arangodb_operator_agency_cache_health_present](./arangodb_operator_agency_cache_health_present.md) | arangodb_operator | agency_cache | Gauge | Determines if local agency cache health is present | -| [arangodb_operator_agency_cache_healthy](./arangodb_operator_agency_cache_healthy.md) | arangodb_operator | agency_cache | Gauge | Determines if agency is healthy | -| [arangodb_operator_agency_cache_leaders](./arangodb_operator_agency_cache_leaders.md) | arangodb_operator | agency_cache | Gauge | Determines agency leader vote count | -| [arangodb_operator_agency_cache_member_commit_offset](./arangodb_operator_agency_cache_member_commit_offset.md) | arangodb_operator | agency_cache | Gauge | Determines agency member commit offset | -| [arangodb_operator_agency_cache_member_serving](./arangodb_operator_agency_cache_member_serving.md) | arangodb_operator | agency_cache | Gauge | Determines if agency member is reachable | -| [arangodb_operator_agency_cache_present](./arangodb_operator_agency_cache_present.md) | arangodb_operator | agency_cache | Gauge | Determines if local agency cache is present | -| [arangodb_operator_agency_cache_serving](./arangodb_operator_agency_cache_serving.md) | arangodb_operator | agency_cache | Gauge | Determines if agency is serving | -| [arangodb_operator_deployment_conditions](./arangodb_operator_deployment_conditions.md) | arangodb_operator | deployment | Gauge | Representation of the ArangoDeployment condition state (true/false) | -| [arangodb_operator_engine_assertions](./arangodb_operator_engine_assertions.md) | arangodb_operator | engine | Counter | Number of assertions invoked during Operator runtime | -| [arangodb_operator_engine_ops_alerts](./arangodb_operator_engine_ops_alerts.md) | arangodb_operator | engine | Counter | Counter for actions which requires ops attention | -| [arangodb_operator_engine_panics_recovered](./arangodb_operator_engine_panics_recovered.md) | arangodb_operator | engine | Counter | Number of Panics recovered inside Operator reconciliation loop | -| [arangodb_operator_kubernetes_client_request_errors](./arangodb_operator_kubernetes_client_request_errors.md) | arangodb_operator | kubernetes_client | Counter | Number of Kubernetes Client request errors | -| [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_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 | -| [arangodb_operator_rebalancer_moves_generated](./arangodb_operator_rebalancer_moves_generated.md) | arangodb_operator | rebalancer | Counter | Define how many moves were generated | -| [arangodb_operator_rebalancer_moves_succeeded](./arangodb_operator_rebalancer_moves_succeeded.md) | arangodb_operator | rebalancer | Counter | Define how many moves succeeded | -| [arangodb_operator_resources_arangodeployment_accepted](./arangodb_operator_resources_arangodeployment_accepted.md) | arangodb_operator | resources | Gauge | Defines if ArangoDeployment has been accepted | -| [arangodb_operator_resources_arangodeployment_immutable_errors](./arangodb_operator_resources_arangodeployment_immutable_errors.md) | arangodb_operator | resources | Counter | Counter for deployment immutable errors | -| [arangodb_operator_resources_arangodeployment_propagated](./arangodb_operator_resources_arangodeployment_propagated.md) | arangodb_operator | resources | Gauge | Defines if ArangoDeployment Spec is propagated | -| [arangodb_operator_resources_arangodeployment_status_restores](./arangodb_operator_resources_arangodeployment_status_restores.md) | arangodb_operator | resources | Counter | Counter for deployment status restored | -| [arangodb_operator_resources_arangodeployment_uptodate](./arangodb_operator_resources_arangodeployment_uptodate.md) | arangodb_operator | resources | Gauge | Defines if ArangoDeployment is uptodate | -| [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 | +| Name | Namespace | Group | Type | Description | +|:-------------------------------------------------------------------------------------------------------------------------------------:|:------------------:|:---------------------:|:-------:|:--------------------------------------------------------------------------------------| +| [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 | +| [arangodb_operator_agency_cache_health_present](./arangodb_operator_agency_cache_health_present.md) | arangodb_operator | agency_cache | Gauge | Determines if local agency cache health is present | +| [arangodb_operator_agency_cache_healthy](./arangodb_operator_agency_cache_healthy.md) | arangodb_operator | agency_cache | Gauge | Determines if agency is healthy | +| [arangodb_operator_agency_cache_leaders](./arangodb_operator_agency_cache_leaders.md) | arangodb_operator | agency_cache | Gauge | Determines agency leader vote count | +| [arangodb_operator_agency_cache_member_commit_offset](./arangodb_operator_agency_cache_member_commit_offset.md) | arangodb_operator | agency_cache | Gauge | Determines agency member commit offset | +| [arangodb_operator_agency_cache_member_serving](./arangodb_operator_agency_cache_member_serving.md) | arangodb_operator | agency_cache | Gauge | Determines if agency member is reachable | +| [arangodb_operator_agency_cache_present](./arangodb_operator_agency_cache_present.md) | arangodb_operator | agency_cache | Gauge | Determines if local agency cache is present | +| [arangodb_operator_agency_cache_serving](./arangodb_operator_agency_cache_serving.md) | arangodb_operator | agency_cache | Gauge | Determines if agency is serving | +| [arangodb_operator_deployment_conditions](./arangodb_operator_deployment_conditions.md) | arangodb_operator | deployment | Gauge | Representation of the ArangoDeployment condition state (true/false) | +| [arangodb_operator_engine_assertions](./arangodb_operator_engine_assertions.md) | arangodb_operator | engine | Counter | Number of assertions invoked during Operator runtime | +| [arangodb_operator_engine_ops_alerts](./arangodb_operator_engine_ops_alerts.md) | arangodb_operator | engine | Counter | Counter for actions which requires ops attention | +| [arangodb_operator_engine_panics_recovered](./arangodb_operator_engine_panics_recovered.md) | arangodb_operator | engine | Counter | Number of Panics recovered inside Operator reconciliation loop | +| [arangodb_operator_kubernetes_client_request_errors](./arangodb_operator_kubernetes_client_request_errors.md) | arangodb_operator | kubernetes_client | Counter | Number of Kubernetes Client request errors | +| [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 | +| [arangodb_operator_rebalancer_moves_generated](./arangodb_operator_rebalancer_moves_generated.md) | arangodb_operator | rebalancer | Counter | Define how many moves were generated | +| [arangodb_operator_rebalancer_moves_succeeded](./arangodb_operator_rebalancer_moves_succeeded.md) | arangodb_operator | rebalancer | Counter | Define how many moves succeeded | +| [arangodb_operator_resources_arangodeployment_accepted](./arangodb_operator_resources_arangodeployment_accepted.md) | arangodb_operator | resources | Gauge | Defines if ArangoDeployment has been accepted | +| [arangodb_operator_resources_arangodeployment_immutable_errors](./arangodb_operator_resources_arangodeployment_immutable_errors.md) | arangodb_operator | resources | Counter | Counter for deployment immutable errors | +| [arangodb_operator_resources_arangodeployment_propagated](./arangodb_operator_resources_arangodeployment_propagated.md) | arangodb_operator | resources | Gauge | Defines if ArangoDeployment Spec is propagated | +| [arangodb_operator_resources_arangodeployment_status_restores](./arangodb_operator_resources_arangodeployment_status_restores.md) | arangodb_operator | resources | Counter | Counter for deployment status restored | +| [arangodb_operator_resources_arangodeployment_uptodate](./arangodb_operator_resources_arangodeployment_uptodate.md) | arangodb_operator | resources | Gauge | Defines if ArangoDeployment is uptodate | +| [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) diff --git a/docs/generated/metrics/arangodb_operator_objects_processed.md b/docs/generated/metrics/arangodb_operator_objects_processed.md new file mode 100644 index 000000000..0964806e8 --- /dev/null +++ b/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 | diff --git a/docs/generated/metrics/arangodb_resources_deployment_config_map_duration.md b/docs/generated/metrics/arangodb_resources_deployment_config_map_duration.md new file mode 100644 index 000000000..856d6b269 --- /dev/null +++ b/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 | diff --git a/docs/generated/metrics/arangodb_resources_deployment_config_map_inspected.md b/docs/generated/metrics/arangodb_resources_deployment_config_map_inspected.md new file mode 100644 index 000000000..34b719489 --- /dev/null +++ b/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 | diff --git a/internal/metrics.go b/internal/metrics.go index 466f544fe..a72a7b150 100644 --- a/internal/metrics.go +++ b/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, ", "), diff --git a/internal/metrics.item.go.tmpl b/internal/metrics.item.go.tmpl index f042dfa8c..043969f29 100644 --- a/internal/metrics.item.go.tmpl +++ b/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 }} diff --git a/internal/metrics.item.go_test.tmpl b/internal/metrics.item.go_test.tmpl index 4167a7156..c8d1a9467 100644 --- a/internal/metrics.item.go_test.tmpl +++ b/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 }} + diff --git a/internal/metrics.yaml b/internal/metrics.yaml index c8bf25aa2..9f1a8b02a 100644 --- a/internal/metrics.yaml +++ b/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" diff --git a/pkg/deployment/resources/config_maps.go b/pkg/deployment/resources/config_maps.go index 495ce477c..0fbf34d89 100644 --- a/pkg/deployment/resources/config_maps.go +++ b/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") } diff --git a/pkg/generated/metric_descriptions/arango_operator_objects_processed.go b/pkg/generated/metric_descriptions/arango_operator_objects_processed.go deleted file mode 100644 index 6408598a2..000000000 --- a/pkg/generated/metric_descriptions/arango_operator_objects_processed.go +++ /dev/null @@ -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 -} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_health_present.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_health_present.go index 76943135d..6ae148012 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_health_present.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_health_present_test.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_health_present_test.go index e5309f5be..b0203d8df 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_health_present_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_healthy.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_healthy.go index a78f59495..a96d07432 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_healthy.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_healthy_test.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_healthy_test.go index c1a6f057e..2deda701a 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_healthy_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_leaders.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_leaders.go index 44d0d104a..ffe945cdb 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_leaders.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_leaders_test.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_leaders_test.go index 358a9c6e3..8f4584c4b 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_leaders_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_commit_offset.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_commit_offset.go index b1d024ade..a9266c730 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_commit_offset.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_commit_offset_test.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_commit_offset_test.go index 575d30893..b8e774c88 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_commit_offset_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_serving.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_serving.go index e61ade3ab..a4dc80aaa 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_serving.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_serving_test.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_serving_test.go index 34d1665c5..7c4742bd0 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_member_serving_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_present.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_present.go index 24cb88aed..695988bf0 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_present.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_present_test.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_present_test.go index 04ef1b512..9c3f2ca93 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_present_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_serving.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_serving.go index f38b126fd..4a1958d9a 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_serving.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_serving_test.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_serving_test.go index 59daee1f6..13ea735fd 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_cache_serving_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_errors.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_errors.go index 232fbee0c..2d0bf3a7a 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_errors.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_errors_test.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_errors_test.go index afbb31371..e6697204f 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_errors_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_fetches.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_fetches.go index bac0258b4..413791541 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_fetches.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_fetches_test.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_fetches_test.go index f0a744812..e5b7c4df5 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_fetches_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_index.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_index.go index 4ca0b865a..d35bc7672 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_index.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_agency_index_test.go b/pkg/generated/metric_descriptions/arangodb_operator_agency_index_test.go index 4ae14ead1..9143f05c1 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_agency_index_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_deployment_conditions.go b/pkg/generated/metric_descriptions/arangodb_operator_deployment_conditions.go index 75172048b..9aa6a820f 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_deployment_conditions.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_deployment_conditions_test.go b/pkg/generated/metric_descriptions/arangodb_operator_deployment_conditions_test.go index 81360d516..951b248ee 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_deployment_conditions_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_engine_assertions.go b/pkg/generated/metric_descriptions/arangodb_operator_engine_assertions.go index 1d73982a8..122263d82 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_engine_assertions.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_engine_assertions_test.go b/pkg/generated/metric_descriptions/arangodb_operator_engine_assertions_test.go index 84655550a..9dd38051a 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_engine_assertions_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_engine_ops_alerts.go b/pkg/generated/metric_descriptions/arangodb_operator_engine_ops_alerts.go index b44159890..a87b7a4bc 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_engine_ops_alerts.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_engine_ops_alerts_test.go b/pkg/generated/metric_descriptions/arangodb_operator_engine_ops_alerts_test.go index 7042cf63a..c7c115541 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_engine_ops_alerts_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_engine_panics_recovered.go b/pkg/generated/metric_descriptions/arangodb_operator_engine_panics_recovered.go index 5aae6d6fa..689e49a4d 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_engine_panics_recovered.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_engine_panics_recovered_test.go b/pkg/generated/metric_descriptions/arangodb_operator_engine_panics_recovered_test.go index 1fb1c4ef5..dbee6979c 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_engine_panics_recovered_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_request_errors.go b/pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_request_errors.go index 406a0b24b..c730c736e 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_request_errors.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_request_errors_test.go b/pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_request_errors_test.go index 130dca568..575709087 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_request_errors_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_requests.go b/pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_requests.go index 225cb2516..f39b0686b 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_requests.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_requests_test.go b/pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_requests_test.go index 58709fb0f..6c8a3eaf8 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_kubernetes_client_requests_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_members_conditions.go b/pkg/generated/metric_descriptions/arangodb_operator_members_conditions.go index 453f5e35a..a4ceddd5f 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_members_conditions.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_members_conditions_test.go b/pkg/generated/metric_descriptions/arangodb_operator_members_conditions_test.go index dd6973530..be3b09e30 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_members_conditions_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_members_unexpected_container_exit_codes.go b/pkg/generated/metric_descriptions/arangodb_operator_members_unexpected_container_exit_codes.go index 925ce528d..a7c290853 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_members_unexpected_container_exit_codes.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_members_unexpected_container_exit_codes_test.go b/pkg/generated/metric_descriptions/arangodb_operator_members_unexpected_container_exit_codes_test.go index 1038437ec..a5d3b230a 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_members_unexpected_container_exit_codes_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_objects_processed.go b/pkg/generated/metric_descriptions/arangodb_operator_objects_processed.go new file mode 100644 index 000000000..0ed680e9e --- /dev/null +++ b/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) +} diff --git a/pkg/generated/metric_descriptions/arango_operator_objects_processed_test.go b/pkg/generated/metric_descriptions/arangodb_operator_objects_processed_test.go similarity index 82% rename from pkg/generated/metric_descriptions/arango_operator_objects_processed_test.go rename to pkg/generated/metric_descriptions/arangodb_operator_objects_processed_test.go index 107f21d30..3412ef3ee 100644 --- a/pkg/generated/metric_descriptions/arango_operator_objects_processed_test.go +++ b/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)) diff --git a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_enabled.go b/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_enabled.go index 703118745..5baae3244 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_enabled.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_enabled_test.go b/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_enabled_test.go index 305e04f0c..78cdf1ffd 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_enabled_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_current.go b/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_current.go index 417db54ac..a45a76708 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_current.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_current_test.go b/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_current_test.go index af13987d9..f8dc0669b 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_current_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_failed.go b/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_failed.go index 928eec8d8..1da064507 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_failed.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_failed_test.go b/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_failed_test.go index 825f8127c..5e482545f 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_failed_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_generated.go b/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_generated.go index d4a43f083..72afbf5f0 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_generated.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_generated_test.go b/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_generated_test.go index e5867b5bf..38c06d7ef 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_generated_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_succeeded.go b/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_succeeded.go index dadf0026f..45e0f8160 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_succeeded.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_succeeded_test.go b/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_succeeded_test.go index 3c7873dcd..46b212245 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_rebalancer_moves_succeeded_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_accepted.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_accepted.go index c2d3159d8..edec35c23 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_accepted.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_accepted_test.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_accepted_test.go index 1496ecb23..eaf6396a0 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_accepted_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_immutable_errors.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_immutable_errors.go index b3e103330..38d5d1650 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_immutable_errors.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_immutable_errors_test.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_immutable_errors_test.go index 92fc12790..17e272302 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_immutable_errors_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_propagated.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_propagated.go index 5bb79cbc0..c079958b6 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_propagated.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_propagated_test.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_propagated_test.go index 8f7edc9f1..c44905191 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_propagated_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_status_restores.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_status_restores.go index 453274d60..afc1edd0a 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_status_restores.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_status_restores_test.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_status_restores_test.go index f87582f55..6cd7ff916 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_status_restores_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_uptodate.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_uptodate.go index 801dae61c..8e5052ec5 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_uptodate.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_uptodate_test.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_uptodate_test.go index 569d115e6..51f3fe896 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_uptodate_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_validation_errors.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_validation_errors.go index 6f369280c..0bac4696f 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_validation_errors.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_validation_errors_test.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_validation_errors_test.go index 7f5db4a80..b6a58a7dc 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeployment_validation_errors_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_active.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_active.go index 2baabad0a..b9f9b738b 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_active.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_active_test.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_active_test.go index caf4fa142..5a4fb5b18 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_active_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_failed.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_failed.go index cc1fd6ab3..3dd09e93f 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_failed.go +++ b/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 } diff --git a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_failed_test.go b/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_failed_test.go index bc723c658..125f1f6ac 100644 --- a/pkg/generated/metric_descriptions/arangodb_operator_resources_arangodeploymentreplication_failed_test.go +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_duration.go b/pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_duration.go new file mode 100644 index 000000000..76212ea76 --- /dev/null +++ b/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) +} diff --git a/pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_duration_test.go b/pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_duration_test.go new file mode 100644 index 000000000..a935c2acd --- /dev/null +++ b/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) + }) +} diff --git a/pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_inspected.go b/pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_inspected.go new file mode 100644 index 000000000..55daf2426 --- /dev/null +++ b/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) +} diff --git a/pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_inspected_test.go b/pkg/generated/metric_descriptions/arangodb_resources_deployment_config_map_inspected_test.go new file mode 100644 index 000000000..f8b45c67d --- /dev/null +++ b/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) + }) +} diff --git a/pkg/operatorV2/operator_worker.go b/pkg/operatorV2/operator_worker.go index 30f6f72f2..620004bb7 100644 --- a/pkg/operatorV2/operator_worker.go +++ b/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, diff --git a/pkg/util/metrics/duration.go b/pkg/util/metrics/duration.go new file mode 100644 index 000000000..93c6860d6 --- /dev/null +++ b/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)) + } +} diff --git a/pkg/util/metrics/factory_counter.go b/pkg/util/metrics/factory_counter.go new file mode 100644 index 000000000..19c41c34b --- /dev/null +++ b/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) +} diff --git a/pkg/util/metrics/factory_gauge.go b/pkg/util/metrics/factory_gauge.go new file mode 100644 index 000000000..5aa283625 --- /dev/null +++ b/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] +}