From 5e8a6c94ee4f3ee1bb04c1b1e8463019d8dfb364 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Mon, 2 May 2022 13:50:08 -0700 Subject: [PATCH] [Metric builder] Replace enum attributes values with typed constants `Record...DataPoint` functions should take one of predefined attribute values instead of any string if the attribute has enum field defined in metadata.yaml. This significantly reduces chance of passing wrong attribute values and helps to ensure accuracy of the automatically generated documentation. --- CHANGELOG.md | 1 + cmd/mdatagen/main.go | 3 + cmd/mdatagen/metrics_v2.tmpl | 60 +- .../internal/metadata/generated_metrics_v2.go | 289 ++-- receiver/activedirectorydsreceiver/scraper.go | 44 +- receiver/apachereceiver/documentation.md | 2 +- .../internal/metadata/generated_metrics_v2.go | 136 +- receiver/apachereceiver/metadata.yaml | 1 + receiver/apachereceiver/scraper.go | 54 +- receiver/apachereceiver/scraper_test.go | 69 +- .../internal/metadata/generated_metrics_v2.go | 147 +- receiver/couchdbreceiver/metrics.go | 12 +- .../internal/metadata/generated_metrics_v2.go | 462 +++++-- receiver/elasticsearchreceiver/scraper.go | 96 +- .../scraper/cpuscraper/cpu_scraper_linux.go | 32 +- .../scraper/cpuscraper/cpu_scraper_others.go | 16 +- .../scraper/cpuscraper/cpu_scraper_test.go | 48 +- .../internal/metadata/generated_metrics_v2.go | 79 +- .../diskscraper/disk_scraper_others.go | 12 +- .../diskscraper/disk_scraper_others_linux.go | 4 +- .../scraper/diskscraper/disk_scraper_test.go | 12 +- .../diskscraper/disk_scraper_windows.go | 12 +- .../internal/metadata/generated_metrics_v2.go | 51 +- .../filesystem_scraper_others.go | 4 +- .../filesystem_scraper_test.go | 9 +- .../filesystem_scraper_unix.go | 10 +- .../internal/metadata/generated_metrics_v2.go | 49 +- .../internal/metadata/generated_metrics_v2.go | 73 +- .../memoryscraper/memory_scraper_linux.go | 24 +- .../memoryscraper/memory_scraper_others.go | 12 +- .../memoryscraper/memory_scraper_test.go | 42 +- .../memoryscraper/memory_scraper_windows.go | 8 +- .../internal/metadata/generated_metrics_v2.go | 84 +- .../scraper/networkscraper/network_scraper.go | 18 +- .../networkscraper/network_scraper_test.go | 9 +- .../internal/metadata/generated_metrics_v2.go | 127 +- .../pagingscraper/paging_scraper_others.go | 24 +- .../pagingscraper/paging_scraper_test.go | 48 +- .../pagingscraper/paging_scraper_windows.go | 12 +- .../internal/metadata/generated_metrics_v2.go | 105 +- .../processesscraper/processes_scraper.go | 4 +- .../processes_scraper_test.go | 19 +- .../processes_scraper_unix.go | 40 +- .../internal/metadata/generated_metrics_v2.go | 84 +- .../scraper/processscraper/process_scraper.go | 4 +- .../processscraper/process_scraper_linux.go | 6 +- .../processscraper/process_scraper_test.go | 15 +- .../processscraper/process_scraper_windows.go | 4 +- .../internal/metadata/generated_metrics_v2.go | 112 +- .../iisreceiver/internal/metadata/recorder.go | 6 +- .../internal/metadata/generated_metrics_v2.go | 213 ++- receiver/memcachedreceiver/scraper.go | 42 +- .../mongodbatlasreceiver/documentation.md | 4 +- .../internal/metadata/generated_metrics_v2.go | 1212 +++++++++++------ .../internal/metadata/metric_name_mapping.go | 326 ++--- receiver/mongodbatlasreceiver/metadata.yaml | 4 +- .../internal/metadata/generated_metrics_v2.go | 186 ++- receiver/mongodbreceiver/metrics.go | 34 +- .../internal/metadata/generated_metrics_v2.go | 760 ++++++++--- receiver/mysqlreceiver/scraper.go | 144 +- .../internal/metadata/generated_metrics_v2.go | 51 +- receiver/nginxreceiver/scraper.go | 8 +- .../internal/metadata/generated_metrics_v2.go | 165 ++- receiver/postgresqlreceiver/scraper.go | 27 +- .../internal/metadata/generated_metrics_v2.go | 39 +- receiver/rabbitmqreceiver/scraper.go | 4 +- .../internal/metadata/generated_metrics_v2.go | 92 +- receiver/riakreceiver/scraper.go | 18 +- .../internal/metadata/generated_metrics_v2.go | 784 +++++++---- receiver/saphanareceiver/queries.go | 115 +- .../internal/metadata/generated_metrics_v2.go | 39 +- .../internal/metadata/metrics_builder_ext.go | 2 +- .../internal/metadata/generated_metrics_v2.go | 78 +- receiver/zookeeperreceiver/metrics.go | 8 +- 74 files changed, 4613 insertions(+), 2336 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index feaedbbd4cc8..829a17a1d58c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,7 @@ - `k8sclusterreceiver`: Validate that k8s API supports a resource before setting up a watcher for it (#9523) - `internal/stanza`: Add support for `remove` operator (#9524) +- `cmd/mdatagen`: Replace enum attributes values with typed constants (#9683) ### 🧰 Bug fixes 🧰 diff --git a/cmd/mdatagen/main.go b/cmd/mdatagen/main.go index 2f7406ac250e..696b140ddf0c 100644 --- a/cmd/mdatagen/main.go +++ b/cmd/mdatagen/main.go @@ -86,6 +86,9 @@ func generateMetrics(ymlDir string, thisDir string, md metadata, useExpGen bool) "publicVar": func(s string) (string, error) { return formatIdentifier(s, true) }, + "attributeInfo": func(an attributeName) attribute { + return md.Attributes[an] + }, "parseImportsRequired": func(metrics map[metricName]metric) bool { for _, m := range metrics { if m.Data().HasMetricInputType() { diff --git a/cmd/mdatagen/metrics_v2.tmpl b/cmd/mdatagen/metrics_v2.tmpl index 24fbce6891cd..38cba8745f9d 100644 --- a/cmd/mdatagen/metrics_v2.tmpl +++ b/cmd/mdatagen/metrics_v2.tmpl @@ -38,6 +38,39 @@ func DefaultMetricsSettings() MetricsSettings { } } +{{ range $name, $info := .Attributes }} +{{- if $info.Enum -}} +// Attribute{{ $name.Render }} specifies the a value {{ $name }} attribute. +type Attribute{{ $name.Render }} int + +const ( + _ Attribute{{ $name.Render }} = iota + {{- range $info.Enum }} + Attribute{{ $name.Render }}{{ . | publicVar }} + {{- end }} +) + +// String returns the string representation of the Attribute{{ $name.Render }}. +func (av Attribute{{ $name.Render }}) String() string { + switch av { + {{- range $info.Enum }} + case Attribute{{ $name.Render }}{{ . | publicVar }}: + return "{{ . }}" + {{- end }} + } + return "" +} + +// MapAttribute{{ $name.Render }} is a helper map of string to Attribute{{ $name.Render }} attribute value. +var MapAttribute{{ $name.Render }} = map[string]Attribute{{ $name.Render }}{ + {{- range $info.Enum }} + "{{ . }}": Attribute{{ $name.Render }}{{ . | publicVar }}, + {{- end }} +} + +{{ end }} +{{- end }} + {{ range $name, $metric := .Metrics -}} type metric{{ $name.Render }} struct { data pmetric.Metric // data buffer for generated metric. @@ -206,7 +239,9 @@ func (mb *MetricsBuilder) Record{{ $name.Render }}DataPoint(ts pcommon.Timestamp {{- else }} {{- if $metric.Data.HasMetricValueType }}, val {{ $metric.Data.MetricValueType.BasicType }}{{- end }} {{- end -}} - {{- range $metric.Attributes -}} , {{ .RenderUnexported }}AttributeValue string{{ end }}) + {{- range $metric.Attributes -}} + , {{ .RenderUnexported }}AttributeValue {{ if (attributeInfo .).Enum }}Attribute{{ .Render }}{{ else }}string{{ end }} + {{- end }}) {{- if $metric.Data.HasMetricInputType }} error{{ end }} { {{- if $metric.Data.HasMetricInputType }} {{- if $metric.Data.HasMetricValueType }} @@ -225,7 +260,9 @@ func (mb *MetricsBuilder) Record{{ $name.Render }}DataPoint(ts pcommon.Timestamp } else { mb.metric{{ $name.Render }}.recordDataPoint(mb.startTime, ts {{- if $metric.Data.HasMetricValueType }}, i {{ end }} - {{- range $metric.Attributes -}} , {{ .RenderUnexported }}AttributeValue{{ end }}) + {{- range $metric.Attributes -}} + , {{ .RenderUnexported }}AttributeValue{{ if (attributeInfo .).Enum }}.String(){{ end }} + {{- end }}) } {{- end }} return nil @@ -233,7 +270,9 @@ func (mb *MetricsBuilder) Record{{ $name.Render }}DataPoint(ts pcommon.Timestamp {{- else }} mb.metric{{ $name.Render }}.recordDataPoint(mb.startTime, ts {{- if $metric.Data.HasMetricValueType }}, val {{ end }} - {{- range $metric.Attributes -}} , {{ .RenderUnexported }}AttributeValue{{ end }}) + {{- range $metric.Attributes -}} + , {{ .RenderUnexported }}AttributeValue{{ if (attributeInfo .).Enum }}.String(){{ end }} + {{- end }}) {{- end }} } {{ end }} @@ -265,18 +304,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -{{ range $name, $info := .Attributes -}} -{{ if $info.Enum -}} -// Attribute{{ $name.Render }} are the possible values that the attribute "{{ $name }}" can have. -var Attribute{{ $name.Render }} = struct { -{{- range $info.Enum }} - {{ . | publicVar }} string -{{- end }} -}{ -{{- range $info.Enum }} - "{{ . }}", -{{- end }} -} -{{ end }} -{{ end }} diff --git a/receiver/activedirectorydsreceiver/internal/metadata/generated_metrics_v2.go b/receiver/activedirectorydsreceiver/internal/metadata/generated_metrics_v2.go index 0e6192a9678a..51cefee645b7 100644 --- a/receiver/activedirectorydsreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/activedirectorydsreceiver/internal/metadata/generated_metrics_v2.go @@ -95,6 +95,196 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeBindType specifies the a value bind_type attribute. +type AttributeBindType int + +const ( + _ AttributeBindType = iota + AttributeBindTypeServer + AttributeBindTypeClient +) + +// String returns the string representation of the AttributeBindType. +func (av AttributeBindType) String() string { + switch av { + case AttributeBindTypeServer: + return "server" + case AttributeBindTypeClient: + return "client" + } + return "" +} + +// MapAttributeBindType is a helper map of string to AttributeBindType attribute value. +var MapAttributeBindType = map[string]AttributeBindType{ + "server": AttributeBindTypeServer, + "client": AttributeBindTypeClient, +} + +// AttributeDirection specifies the a value direction attribute. +type AttributeDirection int + +const ( + _ AttributeDirection = iota + AttributeDirectionSent + AttributeDirectionReceived +) + +// String returns the string representation of the AttributeDirection. +func (av AttributeDirection) String() string { + switch av { + case AttributeDirectionSent: + return "sent" + case AttributeDirectionReceived: + return "received" + } + return "" +} + +// MapAttributeDirection is a helper map of string to AttributeDirection attribute value. +var MapAttributeDirection = map[string]AttributeDirection{ + "sent": AttributeDirectionSent, + "received": AttributeDirectionReceived, +} + +// AttributeNetworkDataType specifies the a value network_data_type attribute. +type AttributeNetworkDataType int + +const ( + _ AttributeNetworkDataType = iota + AttributeNetworkDataTypeCompressed + AttributeNetworkDataTypeUncompressed +) + +// String returns the string representation of the AttributeNetworkDataType. +func (av AttributeNetworkDataType) String() string { + switch av { + case AttributeNetworkDataTypeCompressed: + return "compressed" + case AttributeNetworkDataTypeUncompressed: + return "uncompressed" + } + return "" +} + +// MapAttributeNetworkDataType is a helper map of string to AttributeNetworkDataType attribute value. +var MapAttributeNetworkDataType = map[string]AttributeNetworkDataType{ + "compressed": AttributeNetworkDataTypeCompressed, + "uncompressed": AttributeNetworkDataTypeUncompressed, +} + +// AttributeOperationType specifies the a value operation_type attribute. +type AttributeOperationType int + +const ( + _ AttributeOperationType = iota + AttributeOperationTypeRead + AttributeOperationTypeWrite + AttributeOperationTypeSearch +) + +// String returns the string representation of the AttributeOperationType. +func (av AttributeOperationType) String() string { + switch av { + case AttributeOperationTypeRead: + return "read" + case AttributeOperationTypeWrite: + return "write" + case AttributeOperationTypeSearch: + return "search" + } + return "" +} + +// MapAttributeOperationType is a helper map of string to AttributeOperationType attribute value. +var MapAttributeOperationType = map[string]AttributeOperationType{ + "read": AttributeOperationTypeRead, + "write": AttributeOperationTypeWrite, + "search": AttributeOperationTypeSearch, +} + +// AttributeSuboperationType specifies the a value suboperation_type attribute. +type AttributeSuboperationType int + +const ( + _ AttributeSuboperationType = iota + AttributeSuboperationTypeSecurityDescriptorPropagationsEvent + AttributeSuboperationTypeSearch +) + +// String returns the string representation of the AttributeSuboperationType. +func (av AttributeSuboperationType) String() string { + switch av { + case AttributeSuboperationTypeSecurityDescriptorPropagationsEvent: + return "security_descriptor_propagations_event" + case AttributeSuboperationTypeSearch: + return "search" + } + return "" +} + +// MapAttributeSuboperationType is a helper map of string to AttributeSuboperationType attribute value. +var MapAttributeSuboperationType = map[string]AttributeSuboperationType{ + "security_descriptor_propagations_event": AttributeSuboperationTypeSecurityDescriptorPropagationsEvent, + "search": AttributeSuboperationTypeSearch, +} + +// AttributeSyncResult specifies the a value sync_result attribute. +type AttributeSyncResult int + +const ( + _ AttributeSyncResult = iota + AttributeSyncResultSuccess + AttributeSyncResultSchemaMismatch + AttributeSyncResultOther +) + +// String returns the string representation of the AttributeSyncResult. +func (av AttributeSyncResult) String() string { + switch av { + case AttributeSyncResultSuccess: + return "success" + case AttributeSyncResultSchemaMismatch: + return "schema_mismatch" + case AttributeSyncResultOther: + return "other" + } + return "" +} + +// MapAttributeSyncResult is a helper map of string to AttributeSyncResult attribute value. +var MapAttributeSyncResult = map[string]AttributeSyncResult{ + "success": AttributeSyncResultSuccess, + "schema_mismatch": AttributeSyncResultSchemaMismatch, + "other": AttributeSyncResultOther, +} + +// AttributeValueType specifies the a value value_type attribute. +type AttributeValueType int + +const ( + _ AttributeValueType = iota + AttributeValueTypeDistingushedNames + AttributeValueTypeOther +) + +// String returns the string representation of the AttributeValueType. +func (av AttributeValueType) String() string { + switch av { + case AttributeValueTypeDistingushedNames: + return "distingushed_names" + case AttributeValueTypeOther: + return "other" + } + return "" +} + +// MapAttributeValueType is a helper map of string to AttributeValueType attribute value. +var MapAttributeValueType = map[string]AttributeValueType{ + "distingushed_names": AttributeValueTypeDistingushedNames, + "other": AttributeValueTypeOther, +} + type metricActiveDirectoryDsBindRate struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -1154,8 +1344,8 @@ func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pmetric.Metrics { } // RecordActiveDirectoryDsBindRateDataPoint adds a data point to active_directory.ds.bind.rate metric. -func (mb *MetricsBuilder) RecordActiveDirectoryDsBindRateDataPoint(ts pcommon.Timestamp, val float64, bindTypeAttributeValue string) { - mb.metricActiveDirectoryDsBindRate.recordDataPoint(mb.startTime, ts, val, bindTypeAttributeValue) +func (mb *MetricsBuilder) RecordActiveDirectoryDsBindRateDataPoint(ts pcommon.Timestamp, val float64, bindTypeAttributeValue AttributeBindType) { + mb.metricActiveDirectoryDsBindRate.recordDataPoint(mb.startTime, ts, val, bindTypeAttributeValue.String()) } // RecordActiveDirectoryDsLdapBindLastSuccessfulTimeDataPoint adds a data point to active_directory.ds.ldap.bind.last_successful.time metric. @@ -1189,18 +1379,18 @@ func (mb *MetricsBuilder) RecordActiveDirectoryDsNotificationQueuedDataPoint(ts } // RecordActiveDirectoryDsOperationRateDataPoint adds a data point to active_directory.ds.operation.rate metric. -func (mb *MetricsBuilder) RecordActiveDirectoryDsOperationRateDataPoint(ts pcommon.Timestamp, val float64, operationTypeAttributeValue string) { - mb.metricActiveDirectoryDsOperationRate.recordDataPoint(mb.startTime, ts, val, operationTypeAttributeValue) +func (mb *MetricsBuilder) RecordActiveDirectoryDsOperationRateDataPoint(ts pcommon.Timestamp, val float64, operationTypeAttributeValue AttributeOperationType) { + mb.metricActiveDirectoryDsOperationRate.recordDataPoint(mb.startTime, ts, val, operationTypeAttributeValue.String()) } // RecordActiveDirectoryDsReplicationNetworkIoDataPoint adds a data point to active_directory.ds.replication.network.io metric. -func (mb *MetricsBuilder) RecordActiveDirectoryDsReplicationNetworkIoDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue string, networkDataTypeAttributeValue string) { - mb.metricActiveDirectoryDsReplicationNetworkIo.recordDataPoint(mb.startTime, ts, val, directionAttributeValue, networkDataTypeAttributeValue) +func (mb *MetricsBuilder) RecordActiveDirectoryDsReplicationNetworkIoDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue AttributeDirection, networkDataTypeAttributeValue AttributeNetworkDataType) { + mb.metricActiveDirectoryDsReplicationNetworkIo.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String(), networkDataTypeAttributeValue.String()) } // RecordActiveDirectoryDsReplicationObjectRateDataPoint adds a data point to active_directory.ds.replication.object.rate metric. -func (mb *MetricsBuilder) RecordActiveDirectoryDsReplicationObjectRateDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue string) { - mb.metricActiveDirectoryDsReplicationObjectRate.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordActiveDirectoryDsReplicationObjectRateDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue AttributeDirection) { + mb.metricActiveDirectoryDsReplicationObjectRate.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordActiveDirectoryDsReplicationOperationPendingDataPoint adds a data point to active_directory.ds.replication.operation.pending metric. @@ -1209,8 +1399,8 @@ func (mb *MetricsBuilder) RecordActiveDirectoryDsReplicationOperationPendingData } // RecordActiveDirectoryDsReplicationPropertyRateDataPoint adds a data point to active_directory.ds.replication.property.rate metric. -func (mb *MetricsBuilder) RecordActiveDirectoryDsReplicationPropertyRateDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue string) { - mb.metricActiveDirectoryDsReplicationPropertyRate.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordActiveDirectoryDsReplicationPropertyRateDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue AttributeDirection) { + mb.metricActiveDirectoryDsReplicationPropertyRate.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordActiveDirectoryDsReplicationSyncObjectPendingDataPoint adds a data point to active_directory.ds.replication.sync.object.pending metric. @@ -1219,13 +1409,13 @@ func (mb *MetricsBuilder) RecordActiveDirectoryDsReplicationSyncObjectPendingDat } // RecordActiveDirectoryDsReplicationSyncRequestCountDataPoint adds a data point to active_directory.ds.replication.sync.request.count metric. -func (mb *MetricsBuilder) RecordActiveDirectoryDsReplicationSyncRequestCountDataPoint(ts pcommon.Timestamp, val int64, syncResultAttributeValue string) { - mb.metricActiveDirectoryDsReplicationSyncRequestCount.recordDataPoint(mb.startTime, ts, val, syncResultAttributeValue) +func (mb *MetricsBuilder) RecordActiveDirectoryDsReplicationSyncRequestCountDataPoint(ts pcommon.Timestamp, val int64, syncResultAttributeValue AttributeSyncResult) { + mb.metricActiveDirectoryDsReplicationSyncRequestCount.recordDataPoint(mb.startTime, ts, val, syncResultAttributeValue.String()) } // RecordActiveDirectoryDsReplicationValueRateDataPoint adds a data point to active_directory.ds.replication.value.rate metric. -func (mb *MetricsBuilder) RecordActiveDirectoryDsReplicationValueRateDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue string, valueTypeAttributeValue string) { - mb.metricActiveDirectoryDsReplicationValueRate.recordDataPoint(mb.startTime, ts, val, directionAttributeValue, valueTypeAttributeValue) +func (mb *MetricsBuilder) RecordActiveDirectoryDsReplicationValueRateDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue AttributeDirection, valueTypeAttributeValue AttributeValueType) { + mb.metricActiveDirectoryDsReplicationValueRate.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String(), valueTypeAttributeValue.String()) } // RecordActiveDirectoryDsSecurityDescriptorPropagationsEventQueuedDataPoint adds a data point to active_directory.ds.security_descriptor_propagations_event.queued metric. @@ -1234,8 +1424,8 @@ func (mb *MetricsBuilder) RecordActiveDirectoryDsSecurityDescriptorPropagationsE } // RecordActiveDirectoryDsSuboperationRateDataPoint adds a data point to active_directory.ds.suboperation.rate metric. -func (mb *MetricsBuilder) RecordActiveDirectoryDsSuboperationRateDataPoint(ts pcommon.Timestamp, val float64, suboperationTypeAttributeValue string) { - mb.metricActiveDirectoryDsSuboperationRate.recordDataPoint(mb.startTime, ts, val, suboperationTypeAttributeValue) +func (mb *MetricsBuilder) RecordActiveDirectoryDsSuboperationRateDataPoint(ts pcommon.Timestamp, val float64, suboperationTypeAttributeValue AttributeSuboperationType) { + mb.metricActiveDirectoryDsSuboperationRate.recordDataPoint(mb.startTime, ts, val, suboperationTypeAttributeValue.String()) } // RecordActiveDirectoryDsThreadCountDataPoint adds a data point to active_directory.ds.thread.count metric. @@ -1280,70 +1470,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeBindType are the possible values that the attribute "bind_type" can have. -var AttributeBindType = struct { - Server string - Client string -}{ - "server", - "client", -} - -// AttributeDirection are the possible values that the attribute "direction" can have. -var AttributeDirection = struct { - Sent string - Received string -}{ - "sent", - "received", -} - -// AttributeNetworkDataType are the possible values that the attribute "network_data_type" can have. -var AttributeNetworkDataType = struct { - Compressed string - Uncompressed string -}{ - "compressed", - "uncompressed", -} - -// AttributeOperationType are the possible values that the attribute "operation_type" can have. -var AttributeOperationType = struct { - Read string - Write string - Search string -}{ - "read", - "write", - "search", -} - -// AttributeSuboperationType are the possible values that the attribute "suboperation_type" can have. -var AttributeSuboperationType = struct { - SecurityDescriptorPropagationsEvent string - Search string -}{ - "security_descriptor_propagations_event", - "search", -} - -// AttributeSyncResult are the possible values that the attribute "sync_result" can have. -var AttributeSyncResult = struct { - Success string - SchemaMismatch string - Other string -}{ - "success", - "schema_mismatch", - "other", -} - -// AttributeValueType are the possible values that the attribute "value_type" can have. -var AttributeValueType = struct { - DistingushedNames string - Other string -}{ - "distingushed_names", - "other", -} diff --git a/receiver/activedirectorydsreceiver/scraper.go b/receiver/activedirectorydsreceiver/scraper.go index cb8f0f1bfac6..03a6166c08d7 100644 --- a/receiver/activedirectorydsreceiver/scraper.go +++ b/receiver/activedirectorydsreceiver/scraper.go @@ -62,25 +62,25 @@ func (a *activeDirectoryDSScraper) scrape(ctx context.Context) (pmetric.Metrics, draInboundBytesCompressed, err := a.w.Scrape(draInboundBytesCompressed) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsReplicationNetworkIoDataPoint(now, int64(draInboundBytesCompressed), metadata.AttributeDirection.Received, metadata.AttributeNetworkDataType.Compressed) + a.mb.RecordActiveDirectoryDsReplicationNetworkIoDataPoint(now, int64(draInboundBytesCompressed), metadata.AttributeDirectionReceived, metadata.AttributeNetworkDataTypeCompressed) } draInboundBytesNotCompressed, err := a.w.Scrape(draInboundBytesNotCompressed) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsReplicationNetworkIoDataPoint(now, int64(draInboundBytesNotCompressed), metadata.AttributeDirection.Received, metadata.AttributeNetworkDataType.Uncompressed) + a.mb.RecordActiveDirectoryDsReplicationNetworkIoDataPoint(now, int64(draInboundBytesNotCompressed), metadata.AttributeDirectionReceived, metadata.AttributeNetworkDataTypeUncompressed) } draOutboundBytesCompressed, err := a.w.Scrape(draOutboundBytesCompressed) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsReplicationNetworkIoDataPoint(now, int64(draOutboundBytesCompressed), metadata.AttributeDirection.Sent, metadata.AttributeNetworkDataType.Compressed) + a.mb.RecordActiveDirectoryDsReplicationNetworkIoDataPoint(now, int64(draOutboundBytesCompressed), metadata.AttributeDirectionSent, metadata.AttributeNetworkDataTypeCompressed) } draOutboundBytesNotCompressed, err := a.w.Scrape(draOutboundBytesNotCompressed) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsReplicationNetworkIoDataPoint(now, int64(draOutboundBytesNotCompressed), metadata.AttributeDirection.Sent, metadata.AttributeNetworkDataType.Uncompressed) + a.mb.RecordActiveDirectoryDsReplicationNetworkIoDataPoint(now, int64(draOutboundBytesNotCompressed), metadata.AttributeDirectionSent, metadata.AttributeNetworkDataTypeUncompressed) } draInboundFullSyncObjectsRemaining, err := a.w.Scrape(draInboundFullSyncObjectsRemaining) @@ -92,51 +92,51 @@ func (a *activeDirectoryDSScraper) scrape(ctx context.Context) (pmetric.Metrics, draInboundObjects, err := a.w.Scrape(draInboundObjects) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsReplicationObjectRateDataPoint(now, draInboundObjects, metadata.AttributeDirection.Received) + a.mb.RecordActiveDirectoryDsReplicationObjectRateDataPoint(now, draInboundObjects, metadata.AttributeDirectionReceived) } draOutboundObjects, err := a.w.Scrape(draOutboundObjects) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsReplicationObjectRateDataPoint(now, draOutboundObjects, metadata.AttributeDirection.Sent) + a.mb.RecordActiveDirectoryDsReplicationObjectRateDataPoint(now, draOutboundObjects, metadata.AttributeDirectionSent) } draInboundProperties, err := a.w.Scrape(draInboundProperties) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsReplicationPropertyRateDataPoint(now, draInboundProperties, metadata.AttributeDirection.Received) + a.mb.RecordActiveDirectoryDsReplicationPropertyRateDataPoint(now, draInboundProperties, metadata.AttributeDirectionReceived) } draOutboundProperties, err := a.w.Scrape(draOutboundProperties) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsReplicationPropertyRateDataPoint(now, draOutboundProperties, metadata.AttributeDirection.Sent) + a.mb.RecordActiveDirectoryDsReplicationPropertyRateDataPoint(now, draOutboundProperties, metadata.AttributeDirectionSent) } draInboundValuesDNs, dnsErr := a.w.Scrape(draInboundValuesDNs) multiErr = multierr.Append(multiErr, dnsErr) if dnsErr == nil { - a.mb.RecordActiveDirectoryDsReplicationValueRateDataPoint(now, draInboundValuesDNs, metadata.AttributeDirection.Received, metadata.AttributeValueType.DistingushedNames) + a.mb.RecordActiveDirectoryDsReplicationValueRateDataPoint(now, draInboundValuesDNs, metadata.AttributeDirectionReceived, metadata.AttributeValueTypeDistingushedNames) } draInboundValuesTotal, totalErr := a.w.Scrape(draInboundValuesTotal) multiErr = multierr.Append(multiErr, totalErr) if dnsErr == nil && totalErr == nil { otherValuesInbound := draInboundValuesTotal - draInboundValuesDNs - a.mb.RecordActiveDirectoryDsReplicationValueRateDataPoint(now, otherValuesInbound, metadata.AttributeDirection.Received, metadata.AttributeValueType.Other) + a.mb.RecordActiveDirectoryDsReplicationValueRateDataPoint(now, otherValuesInbound, metadata.AttributeDirectionReceived, metadata.AttributeValueTypeOther) } draOutboundValuesDNs, dnsErr := a.w.Scrape(draOutboundValuesDNs) multiErr = multierr.Append(multiErr, dnsErr) if dnsErr == nil { - a.mb.RecordActiveDirectoryDsReplicationValueRateDataPoint(now, draOutboundValuesDNs, metadata.AttributeDirection.Sent, metadata.AttributeValueType.DistingushedNames) + a.mb.RecordActiveDirectoryDsReplicationValueRateDataPoint(now, draOutboundValuesDNs, metadata.AttributeDirectionSent, metadata.AttributeValueTypeDistingushedNames) } draOutboundValuesTotal, totalErr := a.w.Scrape(draOutboundValuesTotal) multiErr = multierr.Append(multiErr, totalErr) if dnsErr == nil && totalErr == nil { otherValuesOutbound := draOutboundValuesTotal - draOutboundValuesDNs - a.mb.RecordActiveDirectoryDsReplicationValueRateDataPoint(now, otherValuesOutbound, metadata.AttributeDirection.Sent, metadata.AttributeValueType.Other) + a.mb.RecordActiveDirectoryDsReplicationValueRateDataPoint(now, otherValuesOutbound, metadata.AttributeDirectionSent, metadata.AttributeValueTypeOther) } draPendingReplicationOperations, err := a.w.Scrape(draPendingReplicationOperations) @@ -148,50 +148,50 @@ func (a *activeDirectoryDSScraper) scrape(ctx context.Context) (pmetric.Metrics, draSyncFailuresSchemaMistmatch, schemaMismatchErr := a.w.Scrape(draSyncFailuresSchemaMismatch) multiErr = multierr.Append(multiErr, schemaMismatchErr) if schemaMismatchErr == nil { - a.mb.RecordActiveDirectoryDsReplicationSyncRequestCountDataPoint(now, int64(draSyncFailuresSchemaMistmatch), metadata.AttributeSyncResult.SchemaMismatch) + a.mb.RecordActiveDirectoryDsReplicationSyncRequestCountDataPoint(now, int64(draSyncFailuresSchemaMistmatch), metadata.AttributeSyncResultSchemaMismatch) } draSyncRequestsSuccessful, requestsSuccessfulErr := a.w.Scrape(draSyncRequestsSuccessful) multiErr = multierr.Append(multiErr, requestsSuccessfulErr) if requestsSuccessfulErr == nil { - a.mb.RecordActiveDirectoryDsReplicationSyncRequestCountDataPoint(now, int64(draSyncRequestsSuccessful), metadata.AttributeSyncResult.Success) + a.mb.RecordActiveDirectoryDsReplicationSyncRequestCountDataPoint(now, int64(draSyncRequestsSuccessful), metadata.AttributeSyncResultSuccess) } draSyncRequestsTotal, totalErr := a.w.Scrape(draSyncRequestsMade) multiErr = multierr.Append(multiErr, totalErr) if totalErr == nil && requestsSuccessfulErr == nil && schemaMismatchErr == nil { otherReplicationSyncRequests := draSyncRequestsTotal - draSyncRequestsSuccessful - draSyncFailuresSchemaMistmatch - a.mb.RecordActiveDirectoryDsReplicationSyncRequestCountDataPoint(now, int64(otherReplicationSyncRequests), metadata.AttributeSyncResult.Other) + a.mb.RecordActiveDirectoryDsReplicationSyncRequestCountDataPoint(now, int64(otherReplicationSyncRequests), metadata.AttributeSyncResultOther) } dsDirectoryReads, err := a.w.Scrape(dsDirectoryReads) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsOperationRateDataPoint(now, dsDirectoryReads, metadata.AttributeOperationType.Read) + a.mb.RecordActiveDirectoryDsOperationRateDataPoint(now, dsDirectoryReads, metadata.AttributeOperationTypeRead) } dsDirectoryWrites, err := a.w.Scrape(dsDirectoryWrites) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsOperationRateDataPoint(now, dsDirectoryWrites, metadata.AttributeOperationType.Write) + a.mb.RecordActiveDirectoryDsOperationRateDataPoint(now, dsDirectoryWrites, metadata.AttributeOperationTypeWrite) } dsDirectorySearches, err := a.w.Scrape(dsDirectorySearches) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsOperationRateDataPoint(now, dsDirectorySearches, metadata.AttributeOperationType.Search) + a.mb.RecordActiveDirectoryDsOperationRateDataPoint(now, dsDirectorySearches, metadata.AttributeOperationTypeSearch) } dsClientBinds, err := a.w.Scrape(dsClientBinds) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsBindRateDataPoint(now, dsClientBinds, metadata.AttributeBindType.Client) + a.mb.RecordActiveDirectoryDsBindRateDataPoint(now, dsClientBinds, metadata.AttributeBindTypeClient) } dsServerBinds, err := a.w.Scrape(dsServerBinds) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsBindRateDataPoint(now, dsServerBinds, metadata.AttributeBindType.Server) + a.mb.RecordActiveDirectoryDsBindRateDataPoint(now, dsServerBinds, metadata.AttributeBindTypeServer) } dsCacheHitRate, err := a.w.Scrape(dsNameCacheHitRate) @@ -215,13 +215,13 @@ func (a *activeDirectoryDSScraper) scrape(ctx context.Context) (pmetric.Metrics, securityDescSubops, err := a.w.Scrape(dsSecurityDescripterSubOperations) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsSuboperationRateDataPoint(now, securityDescSubops, metadata.AttributeSuboperationType.SecurityDescriptorPropagationsEvent) + a.mb.RecordActiveDirectoryDsSuboperationRateDataPoint(now, securityDescSubops, metadata.AttributeSuboperationTypeSecurityDescriptorPropagationsEvent) } searchSubops, err := a.w.Scrape(dsSearchSubOperations) multiErr = multierr.Append(multiErr, err) if err == nil { - a.mb.RecordActiveDirectoryDsSuboperationRateDataPoint(now, searchSubops, metadata.AttributeSuboperationType.Search) + a.mb.RecordActiveDirectoryDsSuboperationRateDataPoint(now, searchSubops, metadata.AttributeSuboperationTypeSearch) } threadsInUse, err := a.w.Scrape(dsThreadsInUse) diff --git a/receiver/apachereceiver/documentation.md b/receiver/apachereceiver/documentation.md index 247c870df6ec..94abdfa7759e 100644 --- a/receiver/apachereceiver/documentation.md +++ b/receiver/apachereceiver/documentation.md @@ -28,6 +28,6 @@ metrics: | Name | Description | Values | | ---- | ----------- | ------ | -| scoreboard_state (state) | The state of a connection. | open, waiting, starting, reading, sending, keepalive, dnslookup, closing, logging, finishing, idle_cleanup | +| scoreboard_state (state) | The state of a connection. | open, waiting, starting, reading, sending, keepalive, dnslookup, closing, logging, finishing, idle_cleanup, unknown | | server_name | The name of the Apache HTTP server. | | | workers_state (state) | The state of workers. | busy, idle | diff --git a/receiver/apachereceiver/internal/metadata/generated_metrics_v2.go b/receiver/apachereceiver/internal/metadata/generated_metrics_v2.go index 377d5f562c24..2930d755db22 100644 --- a/receiver/apachereceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/apachereceiver/internal/metadata/generated_metrics_v2.go @@ -49,6 +49,98 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeScoreboardState specifies the a value scoreboard_state attribute. +type AttributeScoreboardState int + +const ( + _ AttributeScoreboardState = iota + AttributeScoreboardStateOpen + AttributeScoreboardStateWaiting + AttributeScoreboardStateStarting + AttributeScoreboardStateReading + AttributeScoreboardStateSending + AttributeScoreboardStateKeepalive + AttributeScoreboardStateDnslookup + AttributeScoreboardStateClosing + AttributeScoreboardStateLogging + AttributeScoreboardStateFinishing + AttributeScoreboardStateIdleCleanup + AttributeScoreboardStateUnknown +) + +// String returns the string representation of the AttributeScoreboardState. +func (av AttributeScoreboardState) String() string { + switch av { + case AttributeScoreboardStateOpen: + return "open" + case AttributeScoreboardStateWaiting: + return "waiting" + case AttributeScoreboardStateStarting: + return "starting" + case AttributeScoreboardStateReading: + return "reading" + case AttributeScoreboardStateSending: + return "sending" + case AttributeScoreboardStateKeepalive: + return "keepalive" + case AttributeScoreboardStateDnslookup: + return "dnslookup" + case AttributeScoreboardStateClosing: + return "closing" + case AttributeScoreboardStateLogging: + return "logging" + case AttributeScoreboardStateFinishing: + return "finishing" + case AttributeScoreboardStateIdleCleanup: + return "idle_cleanup" + case AttributeScoreboardStateUnknown: + return "unknown" + } + return "" +} + +// MapAttributeScoreboardState is a helper map of string to AttributeScoreboardState attribute value. +var MapAttributeScoreboardState = map[string]AttributeScoreboardState{ + "open": AttributeScoreboardStateOpen, + "waiting": AttributeScoreboardStateWaiting, + "starting": AttributeScoreboardStateStarting, + "reading": AttributeScoreboardStateReading, + "sending": AttributeScoreboardStateSending, + "keepalive": AttributeScoreboardStateKeepalive, + "dnslookup": AttributeScoreboardStateDnslookup, + "closing": AttributeScoreboardStateClosing, + "logging": AttributeScoreboardStateLogging, + "finishing": AttributeScoreboardStateFinishing, + "idle_cleanup": AttributeScoreboardStateIdleCleanup, + "unknown": AttributeScoreboardStateUnknown, +} + +// AttributeWorkersState specifies the a value workers_state attribute. +type AttributeWorkersState int + +const ( + _ AttributeWorkersState = iota + AttributeWorkersStateBusy + AttributeWorkersStateIdle +) + +// String returns the string representation of the AttributeWorkersState. +func (av AttributeWorkersState) String() string { + switch av { + case AttributeWorkersStateBusy: + return "busy" + case AttributeWorkersStateIdle: + return "idle" + } + return "" +} + +// MapAttributeWorkersState is a helper map of string to AttributeWorkersState attribute value. +var MapAttributeWorkersState = map[string]AttributeWorkersState{ + "busy": AttributeWorkersStateBusy, + "idle": AttributeWorkersStateIdle, +} + type metricApacheCurrentConnections struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -480,8 +572,8 @@ func (mb *MetricsBuilder) RecordApacheRequestsDataPoint(ts pcommon.Timestamp, va } // RecordApacheScoreboardDataPoint adds a data point to apache.scoreboard metric. -func (mb *MetricsBuilder) RecordApacheScoreboardDataPoint(ts pcommon.Timestamp, val int64, serverNameAttributeValue string, scoreboardStateAttributeValue string) { - mb.metricApacheScoreboard.recordDataPoint(mb.startTime, ts, val, serverNameAttributeValue, scoreboardStateAttributeValue) +func (mb *MetricsBuilder) RecordApacheScoreboardDataPoint(ts pcommon.Timestamp, val int64, serverNameAttributeValue string, scoreboardStateAttributeValue AttributeScoreboardState) { + mb.metricApacheScoreboard.recordDataPoint(mb.startTime, ts, val, serverNameAttributeValue, scoreboardStateAttributeValue.String()) } // RecordApacheTrafficDataPoint adds a data point to apache.traffic metric. @@ -500,11 +592,11 @@ func (mb *MetricsBuilder) RecordApacheUptimeDataPoint(ts pcommon.Timestamp, val } // RecordApacheWorkersDataPoint adds a data point to apache.workers metric. -func (mb *MetricsBuilder) RecordApacheWorkersDataPoint(ts pcommon.Timestamp, val string, serverNameAttributeValue string, workersStateAttributeValue string) error { +func (mb *MetricsBuilder) RecordApacheWorkersDataPoint(ts pcommon.Timestamp, val string, serverNameAttributeValue string, workersStateAttributeValue AttributeWorkersState) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for ApacheWorkers, value was %s: %w", val, err) } else { - mb.metricApacheWorkers.recordDataPoint(mb.startTime, ts, i, serverNameAttributeValue, workersStateAttributeValue) + mb.metricApacheWorkers.recordDataPoint(mb.startTime, ts, i, serverNameAttributeValue, workersStateAttributeValue.String()) } return nil } @@ -534,39 +626,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeScoreboardState are the possible values that the attribute "scoreboard_state" can have. -var AttributeScoreboardState = struct { - Open string - Waiting string - Starting string - Reading string - Sending string - Keepalive string - Dnslookup string - Closing string - Logging string - Finishing string - IdleCleanup string -}{ - "open", - "waiting", - "starting", - "reading", - "sending", - "keepalive", - "dnslookup", - "closing", - "logging", - "finishing", - "idle_cleanup", -} - -// AttributeWorkersState are the possible values that the attribute "workers_state" can have. -var AttributeWorkersState = struct { - Busy string - Idle string -}{ - "busy", - "idle", -} diff --git a/receiver/apachereceiver/metadata.yaml b/receiver/apachereceiver/metadata.yaml index d4d2c079dd9b..a8ac95319999 100644 --- a/receiver/apachereceiver/metadata.yaml +++ b/receiver/apachereceiver/metadata.yaml @@ -24,6 +24,7 @@ attributes: - logging - finishing - idle_cleanup + - unknown metrics: apache.uptime: diff --git a/receiver/apachereceiver/scraper.go b/receiver/apachereceiver/scraper.go index 822db0909153..6990e363dc36 100644 --- a/receiver/apachereceiver/scraper.go +++ b/receiver/apachereceiver/scraper.go @@ -79,9 +79,11 @@ func (r *apacheScraper) scrape(context.Context) (pmetric.Metrics, error) { case "ConnsTotal": addPartialIfError(errors, r.mb.RecordApacheCurrentConnectionsDataPoint(now, metricValue, r.cfg.serverName)) case "BusyWorkers": - addPartialIfError(errors, r.mb.RecordApacheWorkersDataPoint(now, metricValue, r.cfg.serverName, "busy")) + addPartialIfError(errors, r.mb.RecordApacheWorkersDataPoint(now, metricValue, r.cfg.serverName, + metadata.AttributeWorkersStateBusy)) case "IdleWorkers": - addPartialIfError(errors, r.mb.RecordApacheWorkersDataPoint(now, metricValue, r.cfg.serverName, "idle")) + addPartialIfError(errors, r.mb.RecordApacheWorkersDataPoint(now, metricValue, r.cfg.serverName, + metadata.AttributeWorkersStateIdle)) case "Total Accesses": addPartialIfError(errors, r.mb.RecordApacheRequestsDataPoint(now, metricValue, r.cfg.serverName)) case "Total kBytes": @@ -139,50 +141,50 @@ func parseStats(resp string) map[string]string { return metrics } -type scoreboardCountsByLabel map[string]int64 +type scoreboardCountsByLabel map[metadata.AttributeScoreboardState]int64 // parseScoreboard quantifies the symbolic mapping of the scoreboard. func parseScoreboard(values string) scoreboardCountsByLabel { scoreboard := scoreboardCountsByLabel{ - "waiting": 0, - "starting": 0, - "reading": 0, - "sending": 0, - "keepalive": 0, - "dnslookup": 0, - "closing": 0, - "logging": 0, - "finishing": 0, - "idle_cleanup": 0, - "open": 0, + metadata.AttributeScoreboardStateWaiting: 0, + metadata.AttributeScoreboardStateStarting: 0, + metadata.AttributeScoreboardStateReading: 0, + metadata.AttributeScoreboardStateSending: 0, + metadata.AttributeScoreboardStateKeepalive: 0, + metadata.AttributeScoreboardStateDnslookup: 0, + metadata.AttributeScoreboardStateClosing: 0, + metadata.AttributeScoreboardStateLogging: 0, + metadata.AttributeScoreboardStateFinishing: 0, + metadata.AttributeScoreboardStateIdleCleanup: 0, + metadata.AttributeScoreboardStateOpen: 0, } for _, char := range values { switch string(char) { case "_": - scoreboard["waiting"]++ + scoreboard[metadata.AttributeScoreboardStateWaiting]++ case "S": - scoreboard["starting"]++ + scoreboard[metadata.AttributeScoreboardStateStarting]++ case "R": - scoreboard["reading"]++ + scoreboard[metadata.AttributeScoreboardStateReading]++ case "W": - scoreboard["sending"]++ + scoreboard[metadata.AttributeScoreboardStateSending]++ case "K": - scoreboard["keepalive"]++ + scoreboard[metadata.AttributeScoreboardStateKeepalive]++ case "D": - scoreboard["dnslookup"]++ + scoreboard[metadata.AttributeScoreboardStateDnslookup]++ case "C": - scoreboard["closing"]++ + scoreboard[metadata.AttributeScoreboardStateClosing]++ case "L": - scoreboard["logging"]++ + scoreboard[metadata.AttributeScoreboardStateLogging]++ case "G": - scoreboard["finishing"]++ + scoreboard[metadata.AttributeScoreboardStateFinishing]++ case "I": - scoreboard["idle_cleanup"]++ + scoreboard[metadata.AttributeScoreboardStateIdleCleanup]++ case ".": - scoreboard["open"]++ + scoreboard[metadata.AttributeScoreboardStateOpen]++ default: - scoreboard["unknown"]++ + scoreboard[metadata.AttributeScoreboardStateUnknown]++ } } return scoreboard diff --git a/receiver/apachereceiver/scraper_test.go b/receiver/apachereceiver/scraper_test.go index 19d7b54f5b9f..1f8a03c81cbf 100644 --- a/receiver/apachereceiver/scraper_test.go +++ b/receiver/apachereceiver/scraper_test.go @@ -30,6 +30,7 @@ import ( "github.com/open-telemetry/opentelemetry-collector-contrib/internal/scrapertest" "github.com/open-telemetry/opentelemetry-collector-contrib/internal/scrapertest/golden" + "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/apachereceiver/internal/metadata" ) func TestScraper(t *testing.T) { @@ -74,52 +75,52 @@ func TestParseScoreboard(t *testing.T) { scoreboard := `S_DD_L_GGG_____W__IIII_C________________W__________________________________.........................____WR______W____W________________________C______________________________________W_W____W______________R_________R________C_________WK_W________K_____W__C__________W___R______.............................................................................................................................` results := parseScoreboard(scoreboard) - require.EqualValues(t, int64(150), results["open"]) - require.EqualValues(t, int64(217), results["waiting"]) - require.EqualValues(t, int64(1), results["starting"]) - require.EqualValues(t, int64(4), results["reading"]) - require.EqualValues(t, int64(12), results["sending"]) - require.EqualValues(t, int64(2), results["keepalive"]) - require.EqualValues(t, int64(2), results["dnslookup"]) - require.EqualValues(t, int64(4), results["closing"]) - require.EqualValues(t, int64(1), results["logging"]) - require.EqualValues(t, int64(3), results["finishing"]) - require.EqualValues(t, int64(4), results["idle_cleanup"]) + require.EqualValues(t, int64(150), results[metadata.AttributeScoreboardStateOpen]) + require.EqualValues(t, int64(217), results[metadata.AttributeScoreboardStateWaiting]) + require.EqualValues(t, int64(1), results[metadata.AttributeScoreboardStateStarting]) + require.EqualValues(t, int64(4), results[metadata.AttributeScoreboardStateReading]) + require.EqualValues(t, int64(12), results[metadata.AttributeScoreboardStateSending]) + require.EqualValues(t, int64(2), results[metadata.AttributeScoreboardStateKeepalive]) + require.EqualValues(t, int64(2), results[metadata.AttributeScoreboardStateDnslookup]) + require.EqualValues(t, int64(4), results[metadata.AttributeScoreboardStateClosing]) + require.EqualValues(t, int64(1), results[metadata.AttributeScoreboardStateLogging]) + require.EqualValues(t, int64(3), results[metadata.AttributeScoreboardStateFinishing]) + require.EqualValues(t, int64(4), results[metadata.AttributeScoreboardStateIdleCleanup]) }) t.Run("test unknown", func(t *testing.T) { scoreboard := `qwertyuiopasdfghjklzxcvbnm` results := parseScoreboard(scoreboard) - require.EqualValues(t, int64(0), results["open"]) - require.EqualValues(t, int64(0), results["waiting"]) - require.EqualValues(t, int64(0), results["starting"]) - require.EqualValues(t, int64(0), results["reading"]) - require.EqualValues(t, int64(0), results["sending"]) - require.EqualValues(t, int64(0), results["keepalive"]) - require.EqualValues(t, int64(0), results["dnslookup"]) - require.EqualValues(t, int64(0), results["closing"]) - require.EqualValues(t, int64(0), results["logging"]) - require.EqualValues(t, int64(0), results["finishing"]) - require.EqualValues(t, int64(0), results["idle_cleanup"]) - require.EqualValues(t, int64(26), results["unknown"]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateOpen]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateWaiting]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateStarting]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateReading]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateSending]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateKeepalive]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateDnslookup]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateClosing]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateLogging]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateFinishing]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateIdleCleanup]) + require.EqualValues(t, int64(26), results[metadata.AttributeScoreboardStateUnknown]) }) t.Run("test empty defaults", func(t *testing.T) { emptyString := "" results := parseScoreboard(emptyString) - require.EqualValues(t, int64(0), results["open"]) - require.EqualValues(t, int64(0), results["waiting"]) - require.EqualValues(t, int64(0), results["starting"]) - require.EqualValues(t, int64(0), results["reading"]) - require.EqualValues(t, int64(0), results["sending"]) - require.EqualValues(t, int64(0), results["keepalive"]) - require.EqualValues(t, int64(0), results["dnslookup"]) - require.EqualValues(t, int64(0), results["closing"]) - require.EqualValues(t, int64(0), results["logging"]) - require.EqualValues(t, int64(0), results["finishing"]) - require.EqualValues(t, int64(0), results["idle_cleanup"]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateOpen]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateWaiting]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateStarting]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateReading]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateSending]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateKeepalive]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateDnslookup]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateClosing]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateLogging]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateFinishing]) + require.EqualValues(t, int64(0), results[metadata.AttributeScoreboardStateIdleCleanup]) }) } diff --git a/receiver/couchdbreceiver/internal/metadata/generated_metrics_v2.go b/receiver/couchdbreceiver/internal/metadata/generated_metrics_v2.go index 0243aaa217fc..ede0c881466f 100644 --- a/receiver/couchdbreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/couchdbreceiver/internal/metadata/generated_metrics_v2.go @@ -55,6 +55,104 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeHTTPMethod specifies the a value http.method attribute. +type AttributeHTTPMethod int + +const ( + _ AttributeHTTPMethod = iota + AttributeHTTPMethodCOPY + AttributeHTTPMethodDELETE + AttributeHTTPMethodGET + AttributeHTTPMethodHEAD + AttributeHTTPMethodOPTIONS + AttributeHTTPMethodPOST + AttributeHTTPMethodPUT +) + +// String returns the string representation of the AttributeHTTPMethod. +func (av AttributeHTTPMethod) String() string { + switch av { + case AttributeHTTPMethodCOPY: + return "COPY" + case AttributeHTTPMethodDELETE: + return "DELETE" + case AttributeHTTPMethodGET: + return "GET" + case AttributeHTTPMethodHEAD: + return "HEAD" + case AttributeHTTPMethodOPTIONS: + return "OPTIONS" + case AttributeHTTPMethodPOST: + return "POST" + case AttributeHTTPMethodPUT: + return "PUT" + } + return "" +} + +// MapAttributeHTTPMethod is a helper map of string to AttributeHTTPMethod attribute value. +var MapAttributeHTTPMethod = map[string]AttributeHTTPMethod{ + "COPY": AttributeHTTPMethodCOPY, + "DELETE": AttributeHTTPMethodDELETE, + "GET": AttributeHTTPMethodGET, + "HEAD": AttributeHTTPMethodHEAD, + "OPTIONS": AttributeHTTPMethodOPTIONS, + "POST": AttributeHTTPMethodPOST, + "PUT": AttributeHTTPMethodPUT, +} + +// AttributeOperation specifies the a value operation attribute. +type AttributeOperation int + +const ( + _ AttributeOperation = iota + AttributeOperationWrites + AttributeOperationReads +) + +// String returns the string representation of the AttributeOperation. +func (av AttributeOperation) String() string { + switch av { + case AttributeOperationWrites: + return "writes" + case AttributeOperationReads: + return "reads" + } + return "" +} + +// MapAttributeOperation is a helper map of string to AttributeOperation attribute value. +var MapAttributeOperation = map[string]AttributeOperation{ + "writes": AttributeOperationWrites, + "reads": AttributeOperationReads, +} + +// AttributeView specifies the a value view attribute. +type AttributeView int + +const ( + _ AttributeView = iota + AttributeViewTemporaryViewReads + AttributeViewViewReads +) + +// String returns the string representation of the AttributeView. +func (av AttributeView) String() string { + switch av { + case AttributeViewTemporaryViewReads: + return "temporary_view_reads" + case AttributeViewViewReads: + return "view_reads" + } + return "" +} + +// MapAttributeView is a helper map of string to AttributeView attribute value. +var MapAttributeView = map[string]AttributeView{ + "temporary_view_reads": AttributeViewTemporaryViewReads, + "view_reads": AttributeViewViewReads, +} + type metricCouchdbAverageRequestTime struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -583,8 +681,8 @@ func (mb *MetricsBuilder) RecordCouchdbDatabaseOpenDataPoint(ts pcommon.Timestam } // RecordCouchdbDatabaseOperationsDataPoint adds a data point to couchdb.database.operations metric. -func (mb *MetricsBuilder) RecordCouchdbDatabaseOperationsDataPoint(ts pcommon.Timestamp, val int64, operationAttributeValue string) { - mb.metricCouchdbDatabaseOperations.recordDataPoint(mb.startTime, ts, val, operationAttributeValue) +func (mb *MetricsBuilder) RecordCouchdbDatabaseOperationsDataPoint(ts pcommon.Timestamp, val int64, operationAttributeValue AttributeOperation) { + mb.metricCouchdbDatabaseOperations.recordDataPoint(mb.startTime, ts, val, operationAttributeValue.String()) } // RecordCouchdbFileDescriptorOpenDataPoint adds a data point to couchdb.file_descriptor.open metric. @@ -598,8 +696,8 @@ func (mb *MetricsBuilder) RecordCouchdbHttpdBulkRequestsDataPoint(ts pcommon.Tim } // RecordCouchdbHttpdRequestsDataPoint adds a data point to couchdb.httpd.requests metric. -func (mb *MetricsBuilder) RecordCouchdbHttpdRequestsDataPoint(ts pcommon.Timestamp, val int64, httpMethodAttributeValue string) { - mb.metricCouchdbHttpdRequests.recordDataPoint(mb.startTime, ts, val, httpMethodAttributeValue) +func (mb *MetricsBuilder) RecordCouchdbHttpdRequestsDataPoint(ts pcommon.Timestamp, val int64, httpMethodAttributeValue AttributeHTTPMethod) { + mb.metricCouchdbHttpdRequests.recordDataPoint(mb.startTime, ts, val, httpMethodAttributeValue.String()) } // RecordCouchdbHttpdResponsesDataPoint adds a data point to couchdb.httpd.responses metric. @@ -608,8 +706,8 @@ func (mb *MetricsBuilder) RecordCouchdbHttpdResponsesDataPoint(ts pcommon.Timest } // RecordCouchdbHttpdViewsDataPoint adds a data point to couchdb.httpd.views metric. -func (mb *MetricsBuilder) RecordCouchdbHttpdViewsDataPoint(ts pcommon.Timestamp, val int64, viewAttributeValue string) { - mb.metricCouchdbHttpdViews.recordDataPoint(mb.startTime, ts, val, viewAttributeValue) +func (mb *MetricsBuilder) RecordCouchdbHttpdViewsDataPoint(ts pcommon.Timestamp, val int64, viewAttributeValue AttributeView) { + mb.metricCouchdbHttpdViews.recordDataPoint(mb.startTime, ts, val, viewAttributeValue.String()) } // Reset resets metrics builder to its initial state. It should be used when external metrics source is restarted, @@ -640,40 +738,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeHTTPMethod are the possible values that the attribute "http.method" can have. -var AttributeHTTPMethod = struct { - COPY string - DELETE string - GET string - HEAD string - OPTIONS string - POST string - PUT string -}{ - "COPY", - "DELETE", - "GET", - "HEAD", - "OPTIONS", - "POST", - "PUT", -} - -// AttributeOperation are the possible values that the attribute "operation" can have. -var AttributeOperation = struct { - Writes string - Reads string -}{ - "writes", - "reads", -} - -// AttributeView are the possible values that the attribute "view" can have. -var AttributeView = struct { - TemporaryViewReads string - ViewReads string -}{ - "temporary_view_reads", - "view_reads", -} diff --git a/receiver/couchdbreceiver/metrics.go b/receiver/couchdbreceiver/metrics.go index 8c047c8e7fe2..e3b0cd2fcbea 100644 --- a/receiver/couchdbreceiver/metrics.go +++ b/receiver/couchdbreceiver/metrics.go @@ -56,9 +56,8 @@ func (c *couchdbScraper) recordCouchdbHttpdBulkRequestsDataPoint(now pcommon.Tim } func (c *couchdbScraper) recordCouchdbHttpdRequestsDataPoint(now pcommon.Timestamp, stats map[string]interface{}, errors scrapererror.ScrapeErrors) { - methods := []string{metadata.AttributeHTTPMethod.COPY, metadata.AttributeHTTPMethod.DELETE, metadata.AttributeHTTPMethod.GET, metadata.AttributeHTTPMethod.HEAD, metadata.AttributeHTTPMethod.OPTIONS, metadata.AttributeHTTPMethod.POST, metadata.AttributeHTTPMethod.PUT} - for _, method := range methods { - httpdRequestMethodKey := []string{"httpd_request_methods", method, "value"} + for methodVal, method := range metadata.MapAttributeHTTPMethod { + httpdRequestMethodKey := []string{"httpd_request_methods", methodVal, "value"} httpdRequestMethodValue, err := getValueFromBody(httpdRequestMethodKey, stats) if err != nil { errors.AddPartial(1, err) @@ -94,9 +93,8 @@ func (c *couchdbScraper) recordCouchdbHttpdResponsesDataPoint(now pcommon.Timest } func (c *couchdbScraper) recordCouchdbHttpdViewsDataPoint(now pcommon.Timestamp, stats map[string]interface{}, errors scrapererror.ScrapeErrors) { - views := []string{metadata.AttributeView.TemporaryViewReads, metadata.AttributeView.ViewReads} - for _, view := range views { - viewKey := []string{"httpd", view, "value"} + for viewVal, view := range metadata.MapAttributeView { + viewKey := []string{"httpd", viewVal, "value"} viewValue, err := getValueFromBody(viewKey, stats) if err != nil { errors.AddPartial(1, err) @@ -145,7 +143,7 @@ func (c *couchdbScraper) recordCouchdbFileDescriptorOpenDataPoint(now pcommon.Ti } func (c *couchdbScraper) recordCouchdbDatabaseOperationsDataPoint(now pcommon.Timestamp, stats map[string]interface{}, errors scrapererror.ScrapeErrors) { - operations := []string{metadata.AttributeOperation.Reads, metadata.AttributeOperation.Writes} + operations := []metadata.AttributeOperation{metadata.AttributeOperationReads, metadata.AttributeOperationWrites} keyPaths := [][]string{{"database_reads", "value"}, {"database_writes", "value"}} for i := 0; i < len(operations); i++ { key := keyPaths[i] diff --git a/receiver/elasticsearchreceiver/internal/metadata/generated_metrics_v2.go b/receiver/elasticsearchreceiver/internal/metadata/generated_metrics_v2.go index 349e6451194f..f839729ac40b 100644 --- a/receiver/elasticsearchreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/elasticsearchreceiver/internal/metadata/generated_metrics_v2.go @@ -139,6 +139,314 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeCacheName specifies the a value cache_name attribute. +type AttributeCacheName int + +const ( + _ AttributeCacheName = iota + AttributeCacheNameFielddata + AttributeCacheNameQuery +) + +// String returns the string representation of the AttributeCacheName. +func (av AttributeCacheName) String() string { + switch av { + case AttributeCacheNameFielddata: + return "fielddata" + case AttributeCacheNameQuery: + return "query" + } + return "" +} + +// MapAttributeCacheName is a helper map of string to AttributeCacheName attribute value. +var MapAttributeCacheName = map[string]AttributeCacheName{ + "fielddata": AttributeCacheNameFielddata, + "query": AttributeCacheNameQuery, +} + +// AttributeDirection specifies the a value direction attribute. +type AttributeDirection int + +const ( + _ AttributeDirection = iota + AttributeDirectionReceived + AttributeDirectionSent +) + +// String returns the string representation of the AttributeDirection. +func (av AttributeDirection) String() string { + switch av { + case AttributeDirectionReceived: + return "received" + case AttributeDirectionSent: + return "sent" + } + return "" +} + +// MapAttributeDirection is a helper map of string to AttributeDirection attribute value. +var MapAttributeDirection = map[string]AttributeDirection{ + "received": AttributeDirectionReceived, + "sent": AttributeDirectionSent, +} + +// AttributeDiskUsageState specifies the a value disk_usage_state attribute. +type AttributeDiskUsageState int + +const ( + _ AttributeDiskUsageState = iota + AttributeDiskUsageStateUsed + AttributeDiskUsageStateFree +) + +// String returns the string representation of the AttributeDiskUsageState. +func (av AttributeDiskUsageState) String() string { + switch av { + case AttributeDiskUsageStateUsed: + return "used" + case AttributeDiskUsageStateFree: + return "free" + } + return "" +} + +// MapAttributeDiskUsageState is a helper map of string to AttributeDiskUsageState attribute value. +var MapAttributeDiskUsageState = map[string]AttributeDiskUsageState{ + "used": AttributeDiskUsageStateUsed, + "free": AttributeDiskUsageStateFree, +} + +// AttributeDocumentState specifies the a value document_state attribute. +type AttributeDocumentState int + +const ( + _ AttributeDocumentState = iota + AttributeDocumentStateActive + AttributeDocumentStateDeleted +) + +// String returns the string representation of the AttributeDocumentState. +func (av AttributeDocumentState) String() string { + switch av { + case AttributeDocumentStateActive: + return "active" + case AttributeDocumentStateDeleted: + return "deleted" + } + return "" +} + +// MapAttributeDocumentState is a helper map of string to AttributeDocumentState attribute value. +var MapAttributeDocumentState = map[string]AttributeDocumentState{ + "active": AttributeDocumentStateActive, + "deleted": AttributeDocumentStateDeleted, +} + +// AttributeFsDirection specifies the a value fs_direction attribute. +type AttributeFsDirection int + +const ( + _ AttributeFsDirection = iota + AttributeFsDirectionRead + AttributeFsDirectionWrite +) + +// String returns the string representation of the AttributeFsDirection. +func (av AttributeFsDirection) String() string { + switch av { + case AttributeFsDirectionRead: + return "read" + case AttributeFsDirectionWrite: + return "write" + } + return "" +} + +// MapAttributeFsDirection is a helper map of string to AttributeFsDirection attribute value. +var MapAttributeFsDirection = map[string]AttributeFsDirection{ + "read": AttributeFsDirectionRead, + "write": AttributeFsDirectionWrite, +} + +// AttributeHealthStatus specifies the a value health_status attribute. +type AttributeHealthStatus int + +const ( + _ AttributeHealthStatus = iota + AttributeHealthStatusGreen + AttributeHealthStatusYellow + AttributeHealthStatusRed +) + +// String returns the string representation of the AttributeHealthStatus. +func (av AttributeHealthStatus) String() string { + switch av { + case AttributeHealthStatusGreen: + return "green" + case AttributeHealthStatusYellow: + return "yellow" + case AttributeHealthStatusRed: + return "red" + } + return "" +} + +// MapAttributeHealthStatus is a helper map of string to AttributeHealthStatus attribute value. +var MapAttributeHealthStatus = map[string]AttributeHealthStatus{ + "green": AttributeHealthStatusGreen, + "yellow": AttributeHealthStatusYellow, + "red": AttributeHealthStatusRed, +} + +// AttributeOperation specifies the a value operation attribute. +type AttributeOperation int + +const ( + _ AttributeOperation = iota + AttributeOperationIndex + AttributeOperationDelete + AttributeOperationGet + AttributeOperationQuery + AttributeOperationFetch + AttributeOperationScroll + AttributeOperationSuggest + AttributeOperationMerge + AttributeOperationRefresh + AttributeOperationFlush + AttributeOperationWarmer +) + +// String returns the string representation of the AttributeOperation. +func (av AttributeOperation) String() string { + switch av { + case AttributeOperationIndex: + return "index" + case AttributeOperationDelete: + return "delete" + case AttributeOperationGet: + return "get" + case AttributeOperationQuery: + return "query" + case AttributeOperationFetch: + return "fetch" + case AttributeOperationScroll: + return "scroll" + case AttributeOperationSuggest: + return "suggest" + case AttributeOperationMerge: + return "merge" + case AttributeOperationRefresh: + return "refresh" + case AttributeOperationFlush: + return "flush" + case AttributeOperationWarmer: + return "warmer" + } + return "" +} + +// MapAttributeOperation is a helper map of string to AttributeOperation attribute value. +var MapAttributeOperation = map[string]AttributeOperation{ + "index": AttributeOperationIndex, + "delete": AttributeOperationDelete, + "get": AttributeOperationGet, + "query": AttributeOperationQuery, + "fetch": AttributeOperationFetch, + "scroll": AttributeOperationScroll, + "suggest": AttributeOperationSuggest, + "merge": AttributeOperationMerge, + "refresh": AttributeOperationRefresh, + "flush": AttributeOperationFlush, + "warmer": AttributeOperationWarmer, +} + +// AttributeShardState specifies the a value shard_state attribute. +type AttributeShardState int + +const ( + _ AttributeShardState = iota + AttributeShardStateActive + AttributeShardStateRelocating + AttributeShardStateInitializing + AttributeShardStateUnassigned +) + +// String returns the string representation of the AttributeShardState. +func (av AttributeShardState) String() string { + switch av { + case AttributeShardStateActive: + return "active" + case AttributeShardStateRelocating: + return "relocating" + case AttributeShardStateInitializing: + return "initializing" + case AttributeShardStateUnassigned: + return "unassigned" + } + return "" +} + +// MapAttributeShardState is a helper map of string to AttributeShardState attribute value. +var MapAttributeShardState = map[string]AttributeShardState{ + "active": AttributeShardStateActive, + "relocating": AttributeShardStateRelocating, + "initializing": AttributeShardStateInitializing, + "unassigned": AttributeShardStateUnassigned, +} + +// AttributeTaskState specifies the a value task_state attribute. +type AttributeTaskState int + +const ( + _ AttributeTaskState = iota + AttributeTaskStateRejected + AttributeTaskStateCompleted +) + +// String returns the string representation of the AttributeTaskState. +func (av AttributeTaskState) String() string { + switch av { + case AttributeTaskStateRejected: + return "rejected" + case AttributeTaskStateCompleted: + return "completed" + } + return "" +} + +// MapAttributeTaskState is a helper map of string to AttributeTaskState attribute value. +var MapAttributeTaskState = map[string]AttributeTaskState{ + "rejected": AttributeTaskStateRejected, + "completed": AttributeTaskStateCompleted, +} + +// AttributeThreadState specifies the a value thread_state attribute. +type AttributeThreadState int + +const ( + _ AttributeThreadState = iota + AttributeThreadStateActive + AttributeThreadStateIdle +) + +// String returns the string representation of the AttributeThreadState. +func (av AttributeThreadState) String() string { + switch av { + case AttributeThreadStateActive: + return "active" + case AttributeThreadStateIdle: + return "idle" + } + return "" +} + +// MapAttributeThreadState is a helper map of string to AttributeThreadState attribute value. +var MapAttributeThreadState = map[string]AttributeThreadState{ + "active": AttributeThreadStateActive, + "idle": AttributeThreadStateIdle, +} + type metricElasticsearchClusterDataNodes struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -1797,8 +2105,8 @@ func (mb *MetricsBuilder) RecordElasticsearchClusterDataNodesDataPoint(ts pcommo } // RecordElasticsearchClusterHealthDataPoint adds a data point to elasticsearch.cluster.health metric. -func (mb *MetricsBuilder) RecordElasticsearchClusterHealthDataPoint(ts pcommon.Timestamp, val int64, healthStatusAttributeValue string) { - mb.metricElasticsearchClusterHealth.recordDataPoint(mb.startTime, ts, val, healthStatusAttributeValue) +func (mb *MetricsBuilder) RecordElasticsearchClusterHealthDataPoint(ts pcommon.Timestamp, val int64, healthStatusAttributeValue AttributeHealthStatus) { + mb.metricElasticsearchClusterHealth.recordDataPoint(mb.startTime, ts, val, healthStatusAttributeValue.String()) } // RecordElasticsearchClusterNodesDataPoint adds a data point to elasticsearch.cluster.nodes metric. @@ -1807,18 +2115,18 @@ func (mb *MetricsBuilder) RecordElasticsearchClusterNodesDataPoint(ts pcommon.Ti } // RecordElasticsearchClusterShardsDataPoint adds a data point to elasticsearch.cluster.shards metric. -func (mb *MetricsBuilder) RecordElasticsearchClusterShardsDataPoint(ts pcommon.Timestamp, val int64, shardStateAttributeValue string) { - mb.metricElasticsearchClusterShards.recordDataPoint(mb.startTime, ts, val, shardStateAttributeValue) +func (mb *MetricsBuilder) RecordElasticsearchClusterShardsDataPoint(ts pcommon.Timestamp, val int64, shardStateAttributeValue AttributeShardState) { + mb.metricElasticsearchClusterShards.recordDataPoint(mb.startTime, ts, val, shardStateAttributeValue.String()) } // RecordElasticsearchNodeCacheEvictionsDataPoint adds a data point to elasticsearch.node.cache.evictions metric. -func (mb *MetricsBuilder) RecordElasticsearchNodeCacheEvictionsDataPoint(ts pcommon.Timestamp, val int64, cacheNameAttributeValue string) { - mb.metricElasticsearchNodeCacheEvictions.recordDataPoint(mb.startTime, ts, val, cacheNameAttributeValue) +func (mb *MetricsBuilder) RecordElasticsearchNodeCacheEvictionsDataPoint(ts pcommon.Timestamp, val int64, cacheNameAttributeValue AttributeCacheName) { + mb.metricElasticsearchNodeCacheEvictions.recordDataPoint(mb.startTime, ts, val, cacheNameAttributeValue.String()) } // RecordElasticsearchNodeCacheMemoryUsageDataPoint adds a data point to elasticsearch.node.cache.memory.usage metric. -func (mb *MetricsBuilder) RecordElasticsearchNodeCacheMemoryUsageDataPoint(ts pcommon.Timestamp, val int64, cacheNameAttributeValue string) { - mb.metricElasticsearchNodeCacheMemoryUsage.recordDataPoint(mb.startTime, ts, val, cacheNameAttributeValue) +func (mb *MetricsBuilder) RecordElasticsearchNodeCacheMemoryUsageDataPoint(ts pcommon.Timestamp, val int64, cacheNameAttributeValue AttributeCacheName) { + mb.metricElasticsearchNodeCacheMemoryUsage.recordDataPoint(mb.startTime, ts, val, cacheNameAttributeValue.String()) } // RecordElasticsearchNodeClusterConnectionsDataPoint adds a data point to elasticsearch.node.cluster.connections metric. @@ -1827,13 +2135,13 @@ func (mb *MetricsBuilder) RecordElasticsearchNodeClusterConnectionsDataPoint(ts } // RecordElasticsearchNodeClusterIoDataPoint adds a data point to elasticsearch.node.cluster.io metric. -func (mb *MetricsBuilder) RecordElasticsearchNodeClusterIoDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue string) { - mb.metricElasticsearchNodeClusterIo.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordElasticsearchNodeClusterIoDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue AttributeDirection) { + mb.metricElasticsearchNodeClusterIo.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordElasticsearchNodeDocumentsDataPoint adds a data point to elasticsearch.node.documents metric. -func (mb *MetricsBuilder) RecordElasticsearchNodeDocumentsDataPoint(ts pcommon.Timestamp, val int64, documentStateAttributeValue string) { - mb.metricElasticsearchNodeDocuments.recordDataPoint(mb.startTime, ts, val, documentStateAttributeValue) +func (mb *MetricsBuilder) RecordElasticsearchNodeDocumentsDataPoint(ts pcommon.Timestamp, val int64, documentStateAttributeValue AttributeDocumentState) { + mb.metricElasticsearchNodeDocuments.recordDataPoint(mb.startTime, ts, val, documentStateAttributeValue.String()) } // RecordElasticsearchNodeFsDiskAvailableDataPoint adds a data point to elasticsearch.node.fs.disk.available metric. @@ -1852,13 +2160,13 @@ func (mb *MetricsBuilder) RecordElasticsearchNodeOpenFilesDataPoint(ts pcommon.T } // RecordElasticsearchNodeOperationsCompletedDataPoint adds a data point to elasticsearch.node.operations.completed metric. -func (mb *MetricsBuilder) RecordElasticsearchNodeOperationsCompletedDataPoint(ts pcommon.Timestamp, val int64, operationAttributeValue string) { - mb.metricElasticsearchNodeOperationsCompleted.recordDataPoint(mb.startTime, ts, val, operationAttributeValue) +func (mb *MetricsBuilder) RecordElasticsearchNodeOperationsCompletedDataPoint(ts pcommon.Timestamp, val int64, operationAttributeValue AttributeOperation) { + mb.metricElasticsearchNodeOperationsCompleted.recordDataPoint(mb.startTime, ts, val, operationAttributeValue.String()) } // RecordElasticsearchNodeOperationsTimeDataPoint adds a data point to elasticsearch.node.operations.time metric. -func (mb *MetricsBuilder) RecordElasticsearchNodeOperationsTimeDataPoint(ts pcommon.Timestamp, val int64, operationAttributeValue string) { - mb.metricElasticsearchNodeOperationsTime.recordDataPoint(mb.startTime, ts, val, operationAttributeValue) +func (mb *MetricsBuilder) RecordElasticsearchNodeOperationsTimeDataPoint(ts pcommon.Timestamp, val int64, operationAttributeValue AttributeOperation) { + mb.metricElasticsearchNodeOperationsTime.recordDataPoint(mb.startTime, ts, val, operationAttributeValue.String()) } // RecordElasticsearchNodeShardsSizeDataPoint adds a data point to elasticsearch.node.shards.size metric. @@ -1867,8 +2175,8 @@ func (mb *MetricsBuilder) RecordElasticsearchNodeShardsSizeDataPoint(ts pcommon. } // RecordElasticsearchNodeThreadPoolTasksFinishedDataPoint adds a data point to elasticsearch.node.thread_pool.tasks.finished metric. -func (mb *MetricsBuilder) RecordElasticsearchNodeThreadPoolTasksFinishedDataPoint(ts pcommon.Timestamp, val int64, threadPoolNameAttributeValue string, taskStateAttributeValue string) { - mb.metricElasticsearchNodeThreadPoolTasksFinished.recordDataPoint(mb.startTime, ts, val, threadPoolNameAttributeValue, taskStateAttributeValue) +func (mb *MetricsBuilder) RecordElasticsearchNodeThreadPoolTasksFinishedDataPoint(ts pcommon.Timestamp, val int64, threadPoolNameAttributeValue string, taskStateAttributeValue AttributeTaskState) { + mb.metricElasticsearchNodeThreadPoolTasksFinished.recordDataPoint(mb.startTime, ts, val, threadPoolNameAttributeValue, taskStateAttributeValue.String()) } // RecordElasticsearchNodeThreadPoolTasksQueuedDataPoint adds a data point to elasticsearch.node.thread_pool.tasks.queued metric. @@ -1877,8 +2185,8 @@ func (mb *MetricsBuilder) RecordElasticsearchNodeThreadPoolTasksQueuedDataPoint( } // RecordElasticsearchNodeThreadPoolThreadsDataPoint adds a data point to elasticsearch.node.thread_pool.threads metric. -func (mb *MetricsBuilder) RecordElasticsearchNodeThreadPoolThreadsDataPoint(ts pcommon.Timestamp, val int64, threadPoolNameAttributeValue string, threadStateAttributeValue string) { - mb.metricElasticsearchNodeThreadPoolThreads.recordDataPoint(mb.startTime, ts, val, threadPoolNameAttributeValue, threadStateAttributeValue) +func (mb *MetricsBuilder) RecordElasticsearchNodeThreadPoolThreadsDataPoint(ts pcommon.Timestamp, val int64, threadPoolNameAttributeValue string, threadStateAttributeValue AttributeThreadState) { + mb.metricElasticsearchNodeThreadPoolThreads.recordDataPoint(mb.startTime, ts, val, threadPoolNameAttributeValue, threadStateAttributeValue.String()) } // RecordJvmClassesLoadedDataPoint adds a data point to jvm.classes.loaded metric. @@ -1997,117 +2305,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeCacheName are the possible values that the attribute "cache_name" can have. -var AttributeCacheName = struct { - Fielddata string - Query string -}{ - "fielddata", - "query", -} - -// AttributeDirection are the possible values that the attribute "direction" can have. -var AttributeDirection = struct { - Received string - Sent string -}{ - "received", - "sent", -} - -// AttributeDiskUsageState are the possible values that the attribute "disk_usage_state" can have. -var AttributeDiskUsageState = struct { - Used string - Free string -}{ - "used", - "free", -} - -// AttributeDocumentState are the possible values that the attribute "document_state" can have. -var AttributeDocumentState = struct { - Active string - Deleted string -}{ - "active", - "deleted", -} - -// AttributeFsDirection are the possible values that the attribute "fs_direction" can have. -var AttributeFsDirection = struct { - Read string - Write string -}{ - "read", - "write", -} - -// AttributeHealthStatus are the possible values that the attribute "health_status" can have. -var AttributeHealthStatus = struct { - Green string - Yellow string - Red string -}{ - "green", - "yellow", - "red", -} - -// AttributeOperation are the possible values that the attribute "operation" can have. -var AttributeOperation = struct { - Index string - Delete string - Get string - Query string - Fetch string - Scroll string - Suggest string - Merge string - Refresh string - Flush string - Warmer string -}{ - "index", - "delete", - "get", - "query", - "fetch", - "scroll", - "suggest", - "merge", - "refresh", - "flush", - "warmer", -} - -// AttributeShardState are the possible values that the attribute "shard_state" can have. -var AttributeShardState = struct { - Active string - Relocating string - Initializing string - Unassigned string -}{ - "active", - "relocating", - "initializing", - "unassigned", -} - -// AttributeTaskState are the possible values that the attribute "task_state" can have. -var AttributeTaskState = struct { - Rejected string - Completed string -}{ - "rejected", - "completed", -} - -// AttributeThreadState are the possible values that the attribute "thread_state" can have. -var AttributeThreadState = struct { - Active string - Idle string -}{ - "active", - "idle", -} diff --git a/receiver/elasticsearchreceiver/scraper.go b/receiver/elasticsearchreceiver/scraper.go index 684038236063..870c4a452028 100644 --- a/receiver/elasticsearchreceiver/scraper.go +++ b/receiver/elasticsearchreceiver/scraper.go @@ -90,59 +90,59 @@ func (r *elasticsearchScraper) scrapeNodeMetrics(ctx context.Context, now pcommo ilms := rm.ScopeMetrics().AppendEmpty() ilms.Scope().SetName(instrumentationLibraryName) - r.mb.RecordElasticsearchNodeCacheMemoryUsageDataPoint(now, info.Indices.FieldDataCache.MemorySizeInBy, metadata.AttributeCacheName.Fielddata) - r.mb.RecordElasticsearchNodeCacheMemoryUsageDataPoint(now, info.Indices.QueryCache.MemorySizeInBy, metadata.AttributeCacheName.Query) + r.mb.RecordElasticsearchNodeCacheMemoryUsageDataPoint(now, info.Indices.FieldDataCache.MemorySizeInBy, metadata.AttributeCacheNameFielddata) + r.mb.RecordElasticsearchNodeCacheMemoryUsageDataPoint(now, info.Indices.QueryCache.MemorySizeInBy, metadata.AttributeCacheNameQuery) - r.mb.RecordElasticsearchNodeCacheEvictionsDataPoint(now, info.Indices.FieldDataCache.Evictions, metadata.AttributeCacheName.Fielddata) - r.mb.RecordElasticsearchNodeCacheEvictionsDataPoint(now, info.Indices.QueryCache.Evictions, metadata.AttributeCacheName.Query) + r.mb.RecordElasticsearchNodeCacheEvictionsDataPoint(now, info.Indices.FieldDataCache.Evictions, metadata.AttributeCacheNameFielddata) + r.mb.RecordElasticsearchNodeCacheEvictionsDataPoint(now, info.Indices.QueryCache.Evictions, metadata.AttributeCacheNameQuery) r.mb.RecordElasticsearchNodeFsDiskAvailableDataPoint(now, info.FS.Total.AvailableBytes) - r.mb.RecordElasticsearchNodeClusterIoDataPoint(now, info.TransportStats.ReceivedBytes, metadata.AttributeDirection.Received) - r.mb.RecordElasticsearchNodeClusterIoDataPoint(now, info.TransportStats.SentBytes, metadata.AttributeDirection.Sent) + r.mb.RecordElasticsearchNodeClusterIoDataPoint(now, info.TransportStats.ReceivedBytes, metadata.AttributeDirectionReceived) + r.mb.RecordElasticsearchNodeClusterIoDataPoint(now, info.TransportStats.SentBytes, metadata.AttributeDirectionSent) r.mb.RecordElasticsearchNodeClusterConnectionsDataPoint(now, info.TransportStats.OpenConnections) r.mb.RecordElasticsearchNodeHTTPConnectionsDataPoint(now, info.HTTPStats.OpenConnections) - r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.IndexingOperations.IndexTotal, metadata.AttributeOperation.Index) - r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.IndexingOperations.DeleteTotal, metadata.AttributeOperation.Delete) - r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.GetOperation.Total, metadata.AttributeOperation.Get) - r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.SearchOperations.QueryTotal, metadata.AttributeOperation.Query) - r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.SearchOperations.FetchTotal, metadata.AttributeOperation.Fetch) - r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.SearchOperations.ScrollTotal, metadata.AttributeOperation.Scroll) - r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.SearchOperations.SuggestTotal, metadata.AttributeOperation.Suggest) - r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.MergeOperations.Total, metadata.AttributeOperation.Merge) - r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.RefreshOperations.Total, metadata.AttributeOperation.Refresh) - r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.FlushOperations.Total, metadata.AttributeOperation.Flush) - r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.WarmerOperations.Total, metadata.AttributeOperation.Warmer) - - r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.IndexingOperations.IndexTimeInMs, metadata.AttributeOperation.Index) - r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.IndexingOperations.DeleteTimeInMs, metadata.AttributeOperation.Delete) - r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.GetOperation.TotalTimeInMs, metadata.AttributeOperation.Get) - r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.SearchOperations.QueryTimeInMs, metadata.AttributeOperation.Query) - r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.SearchOperations.FetchTimeInMs, metadata.AttributeOperation.Fetch) - r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.SearchOperations.ScrollTimeInMs, metadata.AttributeOperation.Scroll) - r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.SearchOperations.SuggestTimeInMs, metadata.AttributeOperation.Suggest) - r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.MergeOperations.TotalTimeInMs, metadata.AttributeOperation.Merge) - r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.RefreshOperations.TotalTimeInMs, metadata.AttributeOperation.Refresh) - r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.FlushOperations.TotalTimeInMs, metadata.AttributeOperation.Flush) - r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.WarmerOperations.TotalTimeInMs, metadata.AttributeOperation.Warmer) + r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.IndexingOperations.IndexTotal, metadata.AttributeOperationIndex) + r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.IndexingOperations.DeleteTotal, metadata.AttributeOperationDelete) + r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.GetOperation.Total, metadata.AttributeOperationGet) + r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.SearchOperations.QueryTotal, metadata.AttributeOperationQuery) + r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.SearchOperations.FetchTotal, metadata.AttributeOperationFetch) + r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.SearchOperations.ScrollTotal, metadata.AttributeOperationScroll) + r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.SearchOperations.SuggestTotal, metadata.AttributeOperationSuggest) + r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.MergeOperations.Total, metadata.AttributeOperationMerge) + r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.RefreshOperations.Total, metadata.AttributeOperationRefresh) + r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.FlushOperations.Total, metadata.AttributeOperationFlush) + r.mb.RecordElasticsearchNodeOperationsCompletedDataPoint(now, info.Indices.WarmerOperations.Total, metadata.AttributeOperationWarmer) + + r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.IndexingOperations.IndexTimeInMs, metadata.AttributeOperationIndex) + r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.IndexingOperations.DeleteTimeInMs, metadata.AttributeOperationDelete) + r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.GetOperation.TotalTimeInMs, metadata.AttributeOperationGet) + r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.SearchOperations.QueryTimeInMs, metadata.AttributeOperationQuery) + r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.SearchOperations.FetchTimeInMs, metadata.AttributeOperationFetch) + r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.SearchOperations.ScrollTimeInMs, metadata.AttributeOperationScroll) + r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.SearchOperations.SuggestTimeInMs, metadata.AttributeOperationSuggest) + r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.MergeOperations.TotalTimeInMs, metadata.AttributeOperationMerge) + r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.RefreshOperations.TotalTimeInMs, metadata.AttributeOperationRefresh) + r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.FlushOperations.TotalTimeInMs, metadata.AttributeOperationFlush) + r.mb.RecordElasticsearchNodeOperationsTimeDataPoint(now, info.Indices.WarmerOperations.TotalTimeInMs, metadata.AttributeOperationWarmer) r.mb.RecordElasticsearchNodeShardsSizeDataPoint(now, info.Indices.StoreInfo.SizeInBy) for tpName, tpInfo := range info.ThreadPoolInfo { - r.mb.RecordElasticsearchNodeThreadPoolThreadsDataPoint(now, tpInfo.ActiveThreads, tpName, metadata.AttributeThreadState.Active) - r.mb.RecordElasticsearchNodeThreadPoolThreadsDataPoint(now, tpInfo.TotalThreads-tpInfo.ActiveThreads, tpName, metadata.AttributeThreadState.Idle) + r.mb.RecordElasticsearchNodeThreadPoolThreadsDataPoint(now, tpInfo.ActiveThreads, tpName, metadata.AttributeThreadStateActive) + r.mb.RecordElasticsearchNodeThreadPoolThreadsDataPoint(now, tpInfo.TotalThreads-tpInfo.ActiveThreads, tpName, metadata.AttributeThreadStateIdle) r.mb.RecordElasticsearchNodeThreadPoolTasksQueuedDataPoint(now, tpInfo.QueuedTasks, tpName) - r.mb.RecordElasticsearchNodeThreadPoolTasksFinishedDataPoint(now, tpInfo.CompletedTasks, tpName, metadata.AttributeTaskState.Completed) - r.mb.RecordElasticsearchNodeThreadPoolTasksFinishedDataPoint(now, tpInfo.RejectedTasks, tpName, metadata.AttributeTaskState.Rejected) + r.mb.RecordElasticsearchNodeThreadPoolTasksFinishedDataPoint(now, tpInfo.CompletedTasks, tpName, metadata.AttributeTaskStateCompleted) + r.mb.RecordElasticsearchNodeThreadPoolTasksFinishedDataPoint(now, tpInfo.RejectedTasks, tpName, metadata.AttributeTaskStateRejected) } - r.mb.RecordElasticsearchNodeDocumentsDataPoint(now, info.Indices.DocumentStats.ActiveCount, metadata.AttributeDocumentState.Active) - r.mb.RecordElasticsearchNodeDocumentsDataPoint(now, info.Indices.DocumentStats.DeletedCount, metadata.AttributeDocumentState.Deleted) + r.mb.RecordElasticsearchNodeDocumentsDataPoint(now, info.Indices.DocumentStats.ActiveCount, metadata.AttributeDocumentStateActive) + r.mb.RecordElasticsearchNodeDocumentsDataPoint(now, info.Indices.DocumentStats.DeletedCount, metadata.AttributeDocumentStateDeleted) r.mb.RecordElasticsearchNodeOpenFilesDataPoint(now, info.ProcessStats.OpenFileDescriptorsCount) @@ -197,24 +197,24 @@ func (r *elasticsearchScraper) scrapeClusterMetrics(ctx context.Context, now pco r.mb.RecordElasticsearchClusterDataNodesDataPoint(now, clusterHealth.DataNodeCount) - r.mb.RecordElasticsearchClusterShardsDataPoint(now, clusterHealth.ActiveShards, metadata.AttributeShardState.Active) - r.mb.RecordElasticsearchClusterShardsDataPoint(now, clusterHealth.InitializingShards, metadata.AttributeShardState.Initializing) - r.mb.RecordElasticsearchClusterShardsDataPoint(now, clusterHealth.RelocatingShards, metadata.AttributeShardState.Relocating) - r.mb.RecordElasticsearchClusterShardsDataPoint(now, clusterHealth.UnassignedShards, metadata.AttributeShardState.Unassigned) + r.mb.RecordElasticsearchClusterShardsDataPoint(now, clusterHealth.ActiveShards, metadata.AttributeShardStateActive) + r.mb.RecordElasticsearchClusterShardsDataPoint(now, clusterHealth.InitializingShards, metadata.AttributeShardStateInitializing) + r.mb.RecordElasticsearchClusterShardsDataPoint(now, clusterHealth.RelocatingShards, metadata.AttributeShardStateRelocating) + r.mb.RecordElasticsearchClusterShardsDataPoint(now, clusterHealth.UnassignedShards, metadata.AttributeShardStateUnassigned) switch clusterHealth.Status { case "green": - r.mb.RecordElasticsearchClusterHealthDataPoint(now, 1, metadata.AttributeHealthStatus.Green) - r.mb.RecordElasticsearchClusterHealthDataPoint(now, 0, metadata.AttributeHealthStatus.Yellow) - r.mb.RecordElasticsearchClusterHealthDataPoint(now, 0, metadata.AttributeHealthStatus.Red) + r.mb.RecordElasticsearchClusterHealthDataPoint(now, 1, metadata.AttributeHealthStatusGreen) + r.mb.RecordElasticsearchClusterHealthDataPoint(now, 0, metadata.AttributeHealthStatusYellow) + r.mb.RecordElasticsearchClusterHealthDataPoint(now, 0, metadata.AttributeHealthStatusRed) case "yellow": - r.mb.RecordElasticsearchClusterHealthDataPoint(now, 0, metadata.AttributeHealthStatus.Green) - r.mb.RecordElasticsearchClusterHealthDataPoint(now, 1, metadata.AttributeHealthStatus.Yellow) - r.mb.RecordElasticsearchClusterHealthDataPoint(now, 0, metadata.AttributeHealthStatus.Red) + r.mb.RecordElasticsearchClusterHealthDataPoint(now, 0, metadata.AttributeHealthStatusGreen) + r.mb.RecordElasticsearchClusterHealthDataPoint(now, 1, metadata.AttributeHealthStatusYellow) + r.mb.RecordElasticsearchClusterHealthDataPoint(now, 0, metadata.AttributeHealthStatusRed) case "red": - r.mb.RecordElasticsearchClusterHealthDataPoint(now, 0, metadata.AttributeHealthStatus.Green) - r.mb.RecordElasticsearchClusterHealthDataPoint(now, 0, metadata.AttributeHealthStatus.Yellow) - r.mb.RecordElasticsearchClusterHealthDataPoint(now, 1, metadata.AttributeHealthStatus.Red) + r.mb.RecordElasticsearchClusterHealthDataPoint(now, 0, metadata.AttributeHealthStatusGreen) + r.mb.RecordElasticsearchClusterHealthDataPoint(now, 0, metadata.AttributeHealthStatusYellow) + r.mb.RecordElasticsearchClusterHealthDataPoint(now, 1, metadata.AttributeHealthStatusRed) default: errs.AddPartial(1, fmt.Errorf("health status %s: %w", clusterHealth.Status, errUnknownClusterStatus)) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/cpu_scraper_linux.go b/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/cpu_scraper_linux.go index 232a1c8ddcb2..f32bd772e37c 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/cpu_scraper_linux.go +++ b/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/cpu_scraper_linux.go @@ -26,23 +26,23 @@ import ( ) func (s *scraper) recordCPUTimeStateDataPoints(now pcommon.Timestamp, cpuTime cpu.TimesStat) { - s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.User, cpuTime.CPU, metadata.AttributeState.User) - s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.System, cpuTime.CPU, metadata.AttributeState.System) - s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Idle, cpuTime.CPU, metadata.AttributeState.Idle) - s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Irq, cpuTime.CPU, metadata.AttributeState.Interrupt) - s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Nice, cpuTime.CPU, metadata.AttributeState.Nice) - s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Softirq, cpuTime.CPU, metadata.AttributeState.Softirq) - s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Steal, cpuTime.CPU, metadata.AttributeState.Steal) - s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Iowait, cpuTime.CPU, metadata.AttributeState.Wait) + s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.User, cpuTime.CPU, metadata.AttributeStateUser) + s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.System, cpuTime.CPU, metadata.AttributeStateSystem) + s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Idle, cpuTime.CPU, metadata.AttributeStateIdle) + s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Irq, cpuTime.CPU, metadata.AttributeStateInterrupt) + s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Nice, cpuTime.CPU, metadata.AttributeStateNice) + s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Softirq, cpuTime.CPU, metadata.AttributeStateSoftirq) + s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Steal, cpuTime.CPU, metadata.AttributeStateSteal) + s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Iowait, cpuTime.CPU, metadata.AttributeStateWait) } func (s *scraper) recordCPUUtilization(now pcommon.Timestamp, cpuUtilization ucal.CPUUtilization) { - s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.User, cpuUtilization.CPU, metadata.AttributeState.User) - s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.System, cpuUtilization.CPU, metadata.AttributeState.System) - s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Idle, cpuUtilization.CPU, metadata.AttributeState.Idle) - s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Irq, cpuUtilization.CPU, metadata.AttributeState.Interrupt) - s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Nice, cpuUtilization.CPU, metadata.AttributeState.Nice) - s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Softirq, cpuUtilization.CPU, metadata.AttributeState.Softirq) - s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Steal, cpuUtilization.CPU, metadata.AttributeState.Steal) - s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Iowait, cpuUtilization.CPU, metadata.AttributeState.Wait) + s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.User, cpuUtilization.CPU, metadata.AttributeStateUser) + s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.System, cpuUtilization.CPU, metadata.AttributeStateSystem) + s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Idle, cpuUtilization.CPU, metadata.AttributeStateIdle) + s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Irq, cpuUtilization.CPU, metadata.AttributeStateInterrupt) + s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Nice, cpuUtilization.CPU, metadata.AttributeStateNice) + s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Softirq, cpuUtilization.CPU, metadata.AttributeStateSoftirq) + s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Steal, cpuUtilization.CPU, metadata.AttributeStateSteal) + s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Iowait, cpuUtilization.CPU, metadata.AttributeStateWait) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/cpu_scraper_others.go b/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/cpu_scraper_others.go index 74a50e0a7105..06e6d7f86b98 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/cpu_scraper_others.go +++ b/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/cpu_scraper_others.go @@ -26,15 +26,15 @@ import ( ) func (s *scraper) recordCPUTimeStateDataPoints(now pcommon.Timestamp, cpuTime cpu.TimesStat) { - s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.User, cpuTime.CPU, metadata.AttributeState.User) - s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.System, cpuTime.CPU, metadata.AttributeState.System) - s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Idle, cpuTime.CPU, metadata.AttributeState.Idle) - s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Irq, cpuTime.CPU, metadata.AttributeState.Interrupt) + s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.User, cpuTime.CPU, metadata.AttributeStateUser) + s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.System, cpuTime.CPU, metadata.AttributeStateSystem) + s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Idle, cpuTime.CPU, metadata.AttributeStateIdle) + s.mb.RecordSystemCPUTimeDataPoint(now, cpuTime.Irq, cpuTime.CPU, metadata.AttributeStateInterrupt) } func (s *scraper) recordCPUUtilization(now pcommon.Timestamp, cpuUtilization ucal.CPUUtilization) { - s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.User, cpuUtilization.CPU, metadata.AttributeState.User) - s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.System, cpuUtilization.CPU, metadata.AttributeState.System) - s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Idle, cpuUtilization.CPU, metadata.AttributeState.Idle) - s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Irq, cpuUtilization.CPU, metadata.AttributeState.Interrupt) + s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.User, cpuUtilization.CPU, metadata.AttributeStateUser) + s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.System, cpuUtilization.CPU, metadata.AttributeStateSystem) + s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Idle, cpuUtilization.CPU, metadata.AttributeStateIdle) + s.mb.RecordSystemCPUUtilizationDataPoint(now, cpuUtilization.Irq, cpuUtilization.CPU, metadata.AttributeStateInterrupt) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/cpu_scraper_test.go b/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/cpu_scraper_test.go index 13351104aaac..f96706435825 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/cpu_scraper_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/cpu_scraper_test.go @@ -360,17 +360,25 @@ func assertCPUMetricValid(t *testing.T, metric pmetric.Metric, startTime pcommon } assert.GreaterOrEqual(t, metric.Sum().DataPoints().Len(), 4*runtime.NumCPU()) internal.AssertSumMetricHasAttribute(t, metric, 0, metadata.Attributes.Cpu) - internal.AssertSumMetricHasAttributeValue(t, metric, 0, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.User)) - internal.AssertSumMetricHasAttributeValue(t, metric, 1, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.System)) - internal.AssertSumMetricHasAttributeValue(t, metric, 2, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Idle)) - internal.AssertSumMetricHasAttributeValue(t, metric, 3, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Interrupt)) + internal.AssertSumMetricHasAttributeValue(t, metric, 0, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateUser.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 1, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateSystem.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 2, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateIdle.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 3, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateInterrupt.String())) } func assertCPUMetricHasLinuxSpecificStateLabels(t *testing.T, metric pmetric.Metric) { - internal.AssertSumMetricHasAttributeValue(t, metric, 4, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Nice)) - internal.AssertSumMetricHasAttributeValue(t, metric, 5, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Softirq)) - internal.AssertSumMetricHasAttributeValue(t, metric, 6, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Steal)) - internal.AssertSumMetricHasAttributeValue(t, metric, 7, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Wait)) + internal.AssertSumMetricHasAttributeValue(t, metric, 4, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateNice.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 5, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateSoftirq.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 6, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateSteal.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 7, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateWait.String())) } func assertCPUUtilizationMetricValid(t *testing.T, metric pmetric.Metric, startTime pcommon.Timestamp) { @@ -384,15 +392,23 @@ func assertCPUUtilizationMetricValid(t *testing.T, metric pmetric.Metric, startT internal.AssertGaugeMetricStartTimeEquals(t, metric, startTime) } internal.AssertGaugeMetricHasAttribute(t, metric, 0, metadata.Attributes.Cpu) - internal.AssertGaugeMetricHasAttributeValue(t, metric, 0, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.User)) - internal.AssertGaugeMetricHasAttributeValue(t, metric, 1, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.System)) - internal.AssertGaugeMetricHasAttributeValue(t, metric, 2, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Idle)) - internal.AssertGaugeMetricHasAttributeValue(t, metric, 3, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Interrupt)) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 0, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateUser.String())) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 1, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateSystem.String())) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 2, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateIdle.String())) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 3, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateInterrupt.String())) } func assertCPUUtilizationMetricHasLinuxSpecificStateLabels(t *testing.T, metric pmetric.Metric) { - internal.AssertGaugeMetricHasAttributeValue(t, metric, 4, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Nice)) - internal.AssertGaugeMetricHasAttributeValue(t, metric, 5, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Softirq)) - internal.AssertGaugeMetricHasAttributeValue(t, metric, 6, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Steal)) - internal.AssertGaugeMetricHasAttributeValue(t, metric, 7, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Wait)) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 4, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateNice.String())) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 5, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateSoftirq.String())) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 6, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateSteal.String())) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 7, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateWait.String())) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/internal/metadata/generated_metrics_v2.go b/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/internal/metadata/generated_metrics_v2.go index b2ace03d4670..3bbec94ce6c2 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/internal/metadata/generated_metrics_v2.go +++ b/receiver/hostmetricsreceiver/internal/scraper/cpuscraper/internal/metadata/generated_metrics_v2.go @@ -32,6 +32,56 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeState specifies the a value state attribute. +type AttributeState int + +const ( + _ AttributeState = iota + AttributeStateIdle + AttributeStateInterrupt + AttributeStateNice + AttributeStateSoftirq + AttributeStateSteal + AttributeStateSystem + AttributeStateUser + AttributeStateWait +) + +// String returns the string representation of the AttributeState. +func (av AttributeState) String() string { + switch av { + case AttributeStateIdle: + return "idle" + case AttributeStateInterrupt: + return "interrupt" + case AttributeStateNice: + return "nice" + case AttributeStateSoftirq: + return "softirq" + case AttributeStateSteal: + return "steal" + case AttributeStateSystem: + return "system" + case AttributeStateUser: + return "user" + case AttributeStateWait: + return "wait" + } + return "" +} + +// MapAttributeState is a helper map of string to AttributeState attribute value. +var MapAttributeState = map[string]AttributeState{ + "idle": AttributeStateIdle, + "interrupt": AttributeStateInterrupt, + "nice": AttributeStateNice, + "softirq": AttributeStateSoftirq, + "steal": AttributeStateSteal, + "system": AttributeStateSystem, + "user": AttributeStateUser, + "wait": AttributeStateWait, +} + type metricSystemCPUTime struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -218,13 +268,13 @@ func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pmetric.Metrics { } // RecordSystemCPUTimeDataPoint adds a data point to system.cpu.time metric. -func (mb *MetricsBuilder) RecordSystemCPUTimeDataPoint(ts pcommon.Timestamp, val float64, cpuAttributeValue string, stateAttributeValue string) { - mb.metricSystemCPUTime.recordDataPoint(mb.startTime, ts, val, cpuAttributeValue, stateAttributeValue) +func (mb *MetricsBuilder) RecordSystemCPUTimeDataPoint(ts pcommon.Timestamp, val float64, cpuAttributeValue string, stateAttributeValue AttributeState) { + mb.metricSystemCPUTime.recordDataPoint(mb.startTime, ts, val, cpuAttributeValue, stateAttributeValue.String()) } // RecordSystemCPUUtilizationDataPoint adds a data point to system.cpu.utilization metric. -func (mb *MetricsBuilder) RecordSystemCPUUtilizationDataPoint(ts pcommon.Timestamp, val float64, cpuAttributeValue string, stateAttributeValue string) { - mb.metricSystemCPUUtilization.recordDataPoint(mb.startTime, ts, val, cpuAttributeValue, stateAttributeValue) +func (mb *MetricsBuilder) RecordSystemCPUUtilizationDataPoint(ts pcommon.Timestamp, val float64, cpuAttributeValue string, stateAttributeValue AttributeState) { + mb.metricSystemCPUUtilization.recordDataPoint(mb.startTime, ts, val, cpuAttributeValue, stateAttributeValue.String()) } // Reset resets metrics builder to its initial state. It should be used when external metrics source is restarted, @@ -249,24 +299,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeState are the possible values that the attribute "state" can have. -var AttributeState = struct { - Idle string - Interrupt string - Nice string - Softirq string - Steal string - System string - User string - Wait string -}{ - "idle", - "interrupt", - "nice", - "softirq", - "steal", - "system", - "user", - "wait", -} diff --git a/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_others.go b/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_others.go index 4433a6d697ce..2c560a019132 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_others.go +++ b/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_others.go @@ -109,15 +109,15 @@ func (s *scraper) scrape(_ context.Context) (pmetric.Metrics, error) { func (s *scraper) recordDiskIOMetric(now pcommon.Timestamp, ioCounters map[string]disk.IOCountersStat) { for device, ioCounter := range ioCounters { - s.mb.RecordSystemDiskIoDataPoint(now, int64(ioCounter.ReadBytes), device, metadata.AttributeDirection.Read) - s.mb.RecordSystemDiskIoDataPoint(now, int64(ioCounter.WriteBytes), device, metadata.AttributeDirection.Write) + s.mb.RecordSystemDiskIoDataPoint(now, int64(ioCounter.ReadBytes), device, metadata.AttributeDirectionRead) + s.mb.RecordSystemDiskIoDataPoint(now, int64(ioCounter.WriteBytes), device, metadata.AttributeDirectionWrite) } } func (s *scraper) recordDiskOperationsMetric(now pcommon.Timestamp, ioCounters map[string]disk.IOCountersStat) { for device, ioCounter := range ioCounters { - s.mb.RecordSystemDiskOperationsDataPoint(now, int64(ioCounter.ReadCount), device, metadata.AttributeDirection.Read) - s.mb.RecordSystemDiskOperationsDataPoint(now, int64(ioCounter.WriteCount), device, metadata.AttributeDirection.Write) + s.mb.RecordSystemDiskOperationsDataPoint(now, int64(ioCounter.ReadCount), device, metadata.AttributeDirectionRead) + s.mb.RecordSystemDiskOperationsDataPoint(now, int64(ioCounter.WriteCount), device, metadata.AttributeDirectionWrite) } } @@ -129,8 +129,8 @@ func (s *scraper) recordDiskIOTimeMetric(now pcommon.Timestamp, ioCounters map[s func (s *scraper) recordDiskOperationTimeMetric(now pcommon.Timestamp, ioCounters map[string]disk.IOCountersStat) { for device, ioCounter := range ioCounters { - s.mb.RecordSystemDiskOperationTimeDataPoint(now, float64(ioCounter.ReadTime)/1e3, device, metadata.AttributeDirection.Read) - s.mb.RecordSystemDiskOperationTimeDataPoint(now, float64(ioCounter.WriteTime)/1e3, device, metadata.AttributeDirection.Write) + s.mb.RecordSystemDiskOperationTimeDataPoint(now, float64(ioCounter.ReadTime)/1e3, device, metadata.AttributeDirectionRead) + s.mb.RecordSystemDiskOperationTimeDataPoint(now, float64(ioCounter.WriteTime)/1e3, device, metadata.AttributeDirectionWrite) } } diff --git a/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_others_linux.go b/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_others_linux.go index cc19343fbeef..501238ae5451 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_others_linux.go +++ b/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_others_linux.go @@ -39,7 +39,7 @@ func (s *scraper) recordDiskWeightedIOTimeMetric(now pcommon.Timestamp, ioCounte func (s *scraper) recordDiskMergedMetric(now pcommon.Timestamp, ioCounters map[string]disk.IOCountersStat) { for device, ioCounter := range ioCounters { - s.mb.RecordSystemDiskMergedDataPoint(now, int64(ioCounter.MergedReadCount), device, metadata.AttributeDirection.Read) - s.mb.RecordSystemDiskMergedDataPoint(now, int64(ioCounter.MergedWriteCount), device, metadata.AttributeDirection.Write) + s.mb.RecordSystemDiskMergedDataPoint(now, int64(ioCounter.MergedReadCount), device, metadata.AttributeDirectionRead) + s.mb.RecordSystemDiskMergedDataPoint(now, int64(ioCounter.MergedWriteCount), device, metadata.AttributeDirectionWrite) } } diff --git a/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_test.go b/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_test.go index cb47e2f0c4ba..00a7d554575b 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_test.go @@ -170,8 +170,10 @@ func assertInt64DiskMetricValid(t *testing.T, metric pmetric.Metric, startTime p assert.GreaterOrEqual(t, metric.Sum().DataPoints().Len(), 2) internal.AssertSumMetricHasAttribute(t, metric, 0, "device") - internal.AssertSumMetricHasAttributeValue(t, metric, 0, "direction", pcommon.NewValueString(metadata.AttributeDirection.Read)) - internal.AssertSumMetricHasAttributeValue(t, metric, 1, "direction", pcommon.NewValueString(metadata.AttributeDirection.Write)) + internal.AssertSumMetricHasAttributeValue(t, metric, 0, "direction", + pcommon.NewValueString(metadata.AttributeDirectionRead.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 1, "direction", + pcommon.NewValueString(metadata.AttributeDirectionWrite.String())) } func assertDoubleDiskMetricValid(t *testing.T, metric pmetric.Metric, expectDirectionLabels bool, startTime pcommon.Timestamp) { @@ -187,8 +189,10 @@ func assertDoubleDiskMetricValid(t *testing.T, metric pmetric.Metric, expectDire internal.AssertSumMetricHasAttribute(t, metric, 0, "device") if expectDirectionLabels { - internal.AssertSumMetricHasAttributeValue(t, metric, 0, "direction", pcommon.NewValueString(metadata.AttributeDirection.Read)) - internal.AssertSumMetricHasAttributeValue(t, metric, metric.Sum().DataPoints().Len()-1, "direction", pcommon.NewValueString(metadata.AttributeDirection.Write)) + internal.AssertSumMetricHasAttributeValue(t, metric, 0, "direction", + pcommon.NewValueString(metadata.AttributeDirectionRead.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, metric.Sum().DataPoints().Len()-1, "direction", + pcommon.NewValueString(metadata.AttributeDirectionWrite.String())) } } diff --git a/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_windows.go b/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_windows.go index 610038b4f94a..fe00803e8a44 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_windows.go +++ b/receiver/hostmetricsreceiver/internal/scraper/diskscraper/disk_scraper_windows.go @@ -132,15 +132,15 @@ func (s *scraper) scrape(ctx context.Context) (pmetric.Metrics, error) { func (s *scraper) recordDiskIOMetric(now pcommon.Timestamp, logicalDiskCounterValues []*perfcounters.CounterValues) { for _, logicalDiskCounter := range logicalDiskCounterValues { - s.mb.RecordSystemDiskIoDataPoint(now, logicalDiskCounter.Values[readBytesPerSec], logicalDiskCounter.InstanceName, metadata.AttributeDirection.Read) - s.mb.RecordSystemDiskIoDataPoint(now, logicalDiskCounter.Values[writeBytesPerSec], logicalDiskCounter.InstanceName, metadata.AttributeDirection.Write) + s.mb.RecordSystemDiskIoDataPoint(now, logicalDiskCounter.Values[readBytesPerSec], logicalDiskCounter.InstanceName, metadata.AttributeDirectionRead) + s.mb.RecordSystemDiskIoDataPoint(now, logicalDiskCounter.Values[writeBytesPerSec], logicalDiskCounter.InstanceName, metadata.AttributeDirectionWrite) } } func (s *scraper) recordDiskOperationsMetric(now pcommon.Timestamp, logicalDiskCounterValues []*perfcounters.CounterValues) { for _, logicalDiskCounter := range logicalDiskCounterValues { - s.mb.RecordSystemDiskOperationsDataPoint(now, logicalDiskCounter.Values[readsPerSec], logicalDiskCounter.InstanceName, metadata.AttributeDirection.Read) - s.mb.RecordSystemDiskOperationsDataPoint(now, logicalDiskCounter.Values[writesPerSec], logicalDiskCounter.InstanceName, metadata.AttributeDirection.Write) + s.mb.RecordSystemDiskOperationsDataPoint(now, logicalDiskCounter.Values[readsPerSec], logicalDiskCounter.InstanceName, metadata.AttributeDirectionRead) + s.mb.RecordSystemDiskOperationsDataPoint(now, logicalDiskCounter.Values[writesPerSec], logicalDiskCounter.InstanceName, metadata.AttributeDirectionWrite) } } @@ -153,8 +153,8 @@ func (s *scraper) recordDiskIOTimeMetric(now pcommon.Timestamp, logicalDiskCount func (s *scraper) recordDiskOperationTimeMetric(now pcommon.Timestamp, logicalDiskCounterValues []*perfcounters.CounterValues) { for _, logicalDiskCounter := range logicalDiskCounterValues { - s.mb.RecordSystemDiskOperationTimeDataPoint(now, float64(logicalDiskCounter.Values[avgDiskSecsPerRead])/1e7, logicalDiskCounter.InstanceName, metadata.AttributeDirection.Read) - s.mb.RecordSystemDiskOperationTimeDataPoint(now, float64(logicalDiskCounter.Values[avgDiskSecsPerWrite])/1e7, logicalDiskCounter.InstanceName, metadata.AttributeDirection.Write) + s.mb.RecordSystemDiskOperationTimeDataPoint(now, float64(logicalDiskCounter.Values[avgDiskSecsPerRead])/1e7, logicalDiskCounter.InstanceName, metadata.AttributeDirectionRead) + s.mb.RecordSystemDiskOperationTimeDataPoint(now, float64(logicalDiskCounter.Values[avgDiskSecsPerWrite])/1e7, logicalDiskCounter.InstanceName, metadata.AttributeDirectionWrite) } } diff --git a/receiver/hostmetricsreceiver/internal/scraper/diskscraper/internal/metadata/generated_metrics_v2.go b/receiver/hostmetricsreceiver/internal/scraper/diskscraper/internal/metadata/generated_metrics_v2.go index 125e4a119d94..0f5bcd7e37f4 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/diskscraper/internal/metadata/generated_metrics_v2.go +++ b/receiver/hostmetricsreceiver/internal/scraper/diskscraper/internal/metadata/generated_metrics_v2.go @@ -52,6 +52,32 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeDirection specifies the a value direction attribute. +type AttributeDirection int + +const ( + _ AttributeDirection = iota + AttributeDirectionRead + AttributeDirectionWrite +) + +// String returns the string representation of the AttributeDirection. +func (av AttributeDirection) String() string { + switch av { + case AttributeDirectionRead: + return "read" + case AttributeDirectionWrite: + return "write" + } + return "" +} + +// MapAttributeDirection is a helper map of string to AttributeDirection attribute value. +var MapAttributeDirection = map[string]AttributeDirection{ + "read": AttributeDirectionRead, + "write": AttributeDirectionWrite, +} + type metricSystemDiskIo struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -522,8 +548,8 @@ func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pmetric.Metrics { } // RecordSystemDiskIoDataPoint adds a data point to system.disk.io metric. -func (mb *MetricsBuilder) RecordSystemDiskIoDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue string) { - mb.metricSystemDiskIo.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue) +func (mb *MetricsBuilder) RecordSystemDiskIoDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue AttributeDirection) { + mb.metricSystemDiskIo.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue.String()) } // RecordSystemDiskIoTimeDataPoint adds a data point to system.disk.io_time metric. @@ -532,18 +558,18 @@ func (mb *MetricsBuilder) RecordSystemDiskIoTimeDataPoint(ts pcommon.Timestamp, } // RecordSystemDiskMergedDataPoint adds a data point to system.disk.merged metric. -func (mb *MetricsBuilder) RecordSystemDiskMergedDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue string) { - mb.metricSystemDiskMerged.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue) +func (mb *MetricsBuilder) RecordSystemDiskMergedDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue AttributeDirection) { + mb.metricSystemDiskMerged.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue.String()) } // RecordSystemDiskOperationTimeDataPoint adds a data point to system.disk.operation_time metric. -func (mb *MetricsBuilder) RecordSystemDiskOperationTimeDataPoint(ts pcommon.Timestamp, val float64, deviceAttributeValue string, directionAttributeValue string) { - mb.metricSystemDiskOperationTime.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue) +func (mb *MetricsBuilder) RecordSystemDiskOperationTimeDataPoint(ts pcommon.Timestamp, val float64, deviceAttributeValue string, directionAttributeValue AttributeDirection) { + mb.metricSystemDiskOperationTime.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue.String()) } // RecordSystemDiskOperationsDataPoint adds a data point to system.disk.operations metric. -func (mb *MetricsBuilder) RecordSystemDiskOperationsDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue string) { - mb.metricSystemDiskOperations.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue) +func (mb *MetricsBuilder) RecordSystemDiskOperationsDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue AttributeDirection) { + mb.metricSystemDiskOperations.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue.String()) } // RecordSystemDiskPendingOperationsDataPoint adds a data point to system.disk.pending_operations metric. @@ -578,12 +604,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeDirection are the possible values that the attribute "direction" can have. -var AttributeDirection = struct { - Read string - Write string -}{ - "read", - "write", -} diff --git a/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/filesystem_scraper_others.go b/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/filesystem_scraper_others.go index 4b09c10f2199..b7d3edda1782 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/filesystem_scraper_others.go +++ b/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/filesystem_scraper_others.go @@ -31,12 +31,12 @@ func (s *scraper) recordFileSystemUsageMetric(now pcommon.Timestamp, deviceUsage now, int64(deviceUsage.usage.Used), deviceUsage.partition.Device, getMountMode(deviceUsage.partition.Opts), deviceUsage.partition.Mountpoint, deviceUsage.partition.Fstype, - metadata.AttributeState.Used) + metadata.AttributeStateUsed) s.mb.RecordSystemFilesystemUsageDataPoint( now, int64(deviceUsage.usage.Free), deviceUsage.partition.Device, getMountMode(deviceUsage.partition.Opts), deviceUsage.partition.Mountpoint, deviceUsage.partition.Fstype, - metadata.AttributeState.Free) + metadata.AttributeStateFree) s.mb.RecordSystemFilesystemUtilizationDataPoint( now, deviceUsage.usage.UsedPercent/100.0, deviceUsage.partition.Device, getMountMode(deviceUsage.partition.Opts), diff --git a/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/filesystem_scraper_test.go b/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/filesystem_scraper_test.go index f1e7d00a89df..a8688a426dec 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/filesystem_scraper_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/filesystem_scraper_test.go @@ -321,12 +321,15 @@ func assertFileSystemUsageMetricValid( } else { assert.GreaterOrEqual(t, metric.Sum().DataPoints().Len(), fileSystemStatesLen) } - internal.AssertSumMetricHasAttributeValue(t, metric, 0, "state", pcommon.NewValueString(metadata.AttributeState.Used)) - internal.AssertSumMetricHasAttributeValue(t, metric, 1, "state", pcommon.NewValueString(metadata.AttributeState.Free)) + internal.AssertSumMetricHasAttributeValue(t, metric, 0, "state", + pcommon.NewValueString(metadata.AttributeStateUsed.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 1, "state", + pcommon.NewValueString(metadata.AttributeStateFree.String())) } func assertFileSystemUsageMetricHasUnixSpecificStateLabels(t *testing.T, metric pmetric.Metric) { - internal.AssertSumMetricHasAttributeValue(t, metric, 2, "state", pcommon.NewValueString(metadata.AttributeState.Reserved)) + internal.AssertSumMetricHasAttributeValue(t, metric, 2, "state", + pcommon.NewValueString(metadata.AttributeStateReserved.String())) } func isUnix() bool { diff --git a/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/filesystem_scraper_unix.go b/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/filesystem_scraper_unix.go index 3e8857bfac5d..59e0e45605b0 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/filesystem_scraper_unix.go +++ b/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/filesystem_scraper_unix.go @@ -31,17 +31,17 @@ func (s *scraper) recordFileSystemUsageMetric(now pcommon.Timestamp, deviceUsage now, int64(deviceUsage.usage.Used), deviceUsage.partition.Device, getMountMode(deviceUsage.partition.Opts), deviceUsage.partition.Mountpoint, deviceUsage.partition.Fstype, - metadata.AttributeState.Used) + metadata.AttributeStateUsed) s.mb.RecordSystemFilesystemUsageDataPoint( now, int64(deviceUsage.usage.Free), deviceUsage.partition.Device, getMountMode(deviceUsage.partition.Opts), deviceUsage.partition.Mountpoint, deviceUsage.partition.Fstype, - metadata.AttributeState.Free) + metadata.AttributeStateFree) s.mb.RecordSystemFilesystemUsageDataPoint( now, int64(deviceUsage.usage.Total-deviceUsage.usage.Used-deviceUsage.usage.Free), deviceUsage.partition.Device, getMountMode(deviceUsage.partition.Opts), deviceUsage.partition.Mountpoint, deviceUsage.partition.Fstype, - metadata.AttributeState.Reserved) + metadata.AttributeStateReserved) s.mb.RecordSystemFilesystemUtilizationDataPoint( now, deviceUsage.usage.UsedPercent/100.0, deviceUsage.partition.Device, getMountMode(deviceUsage.partition.Opts), @@ -56,10 +56,10 @@ func (s *scraper) recordSystemSpecificMetrics(now pcommon.Timestamp, deviceUsage s.mb.RecordSystemFilesystemInodesUsageDataPoint( now, int64(deviceUsage.usage.InodesUsed), deviceUsage.partition.Device, getMountMode(deviceUsage.partition.Opts), deviceUsage.partition.Mountpoint, - deviceUsage.partition.Fstype, metadata.AttributeState.Used) + deviceUsage.partition.Fstype, metadata.AttributeStateUsed) s.mb.RecordSystemFilesystemInodesUsageDataPoint( now, int64(deviceUsage.usage.InodesFree), deviceUsage.partition.Device, getMountMode(deviceUsage.partition.Opts), deviceUsage.partition.Mountpoint, - deviceUsage.partition.Fstype, metadata.AttributeState.Free) + deviceUsage.partition.Fstype, metadata.AttributeStateFree) } } diff --git a/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/internal/metadata/generated_metrics_v2.go b/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/internal/metadata/generated_metrics_v2.go index 9a26a0a5b6b4..5ab67bef2162 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/internal/metadata/generated_metrics_v2.go +++ b/receiver/hostmetricsreceiver/internal/scraper/filesystemscraper/internal/metadata/generated_metrics_v2.go @@ -36,6 +36,36 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeState specifies the a value state attribute. +type AttributeState int + +const ( + _ AttributeState = iota + AttributeStateFree + AttributeStateReserved + AttributeStateUsed +) + +// String returns the string representation of the AttributeState. +func (av AttributeState) String() string { + switch av { + case AttributeStateFree: + return "free" + case AttributeStateReserved: + return "reserved" + case AttributeStateUsed: + return "used" + } + return "" +} + +// MapAttributeState is a helper map of string to AttributeState attribute value. +var MapAttributeState = map[string]AttributeState{ + "free": AttributeStateFree, + "reserved": AttributeStateReserved, + "used": AttributeStateUsed, +} + type metricSystemFilesystemInodesUsage struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -287,13 +317,13 @@ func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pmetric.Metrics { } // RecordSystemFilesystemInodesUsageDataPoint adds a data point to system.filesystem.inodes.usage metric. -func (mb *MetricsBuilder) RecordSystemFilesystemInodesUsageDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, modeAttributeValue string, mountpointAttributeValue string, typeAttributeValue string, stateAttributeValue string) { - mb.metricSystemFilesystemInodesUsage.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, modeAttributeValue, mountpointAttributeValue, typeAttributeValue, stateAttributeValue) +func (mb *MetricsBuilder) RecordSystemFilesystemInodesUsageDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, modeAttributeValue string, mountpointAttributeValue string, typeAttributeValue string, stateAttributeValue AttributeState) { + mb.metricSystemFilesystemInodesUsage.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, modeAttributeValue, mountpointAttributeValue, typeAttributeValue, stateAttributeValue.String()) } // RecordSystemFilesystemUsageDataPoint adds a data point to system.filesystem.usage metric. -func (mb *MetricsBuilder) RecordSystemFilesystemUsageDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, modeAttributeValue string, mountpointAttributeValue string, typeAttributeValue string, stateAttributeValue string) { - mb.metricSystemFilesystemUsage.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, modeAttributeValue, mountpointAttributeValue, typeAttributeValue, stateAttributeValue) +func (mb *MetricsBuilder) RecordSystemFilesystemUsageDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, modeAttributeValue string, mountpointAttributeValue string, typeAttributeValue string, stateAttributeValue AttributeState) { + mb.metricSystemFilesystemUsage.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, modeAttributeValue, mountpointAttributeValue, typeAttributeValue, stateAttributeValue.String()) } // RecordSystemFilesystemUtilizationDataPoint adds a data point to system.filesystem.utilization metric. @@ -332,14 +362,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeState are the possible values that the attribute "state" can have. -var AttributeState = struct { - Free string - Reserved string - Used string -}{ - "free", - "reserved", - "used", -} diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_metrics_v2.go b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_metrics_v2.go index 6404db9cb32e..31f308261311 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_metrics_v2.go +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_metrics_v2.go @@ -32,6 +32,52 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeState specifies the a value state attribute. +type AttributeState int + +const ( + _ AttributeState = iota + AttributeStateBuffered + AttributeStateCached + AttributeStateInactive + AttributeStateFree + AttributeStateSlabReclaimable + AttributeStateSlabUnreclaimable + AttributeStateUsed +) + +// String returns the string representation of the AttributeState. +func (av AttributeState) String() string { + switch av { + case AttributeStateBuffered: + return "buffered" + case AttributeStateCached: + return "cached" + case AttributeStateInactive: + return "inactive" + case AttributeStateFree: + return "free" + case AttributeStateSlabReclaimable: + return "slab_reclaimable" + case AttributeStateSlabUnreclaimable: + return "slab_unreclaimable" + case AttributeStateUsed: + return "used" + } + return "" +} + +// MapAttributeState is a helper map of string to AttributeState attribute value. +var MapAttributeState = map[string]AttributeState{ + "buffered": AttributeStateBuffered, + "cached": AttributeStateCached, + "inactive": AttributeStateInactive, + "free": AttributeStateFree, + "slab_reclaimable": AttributeStateSlabReclaimable, + "slab_unreclaimable": AttributeStateSlabUnreclaimable, + "used": AttributeStateUsed, +} + type metricSystemMemoryUsage struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -216,13 +262,13 @@ func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pmetric.Metrics { } // RecordSystemMemoryUsageDataPoint adds a data point to system.memory.usage metric. -func (mb *MetricsBuilder) RecordSystemMemoryUsageDataPoint(ts pcommon.Timestamp, val int64, stateAttributeValue string) { - mb.metricSystemMemoryUsage.recordDataPoint(mb.startTime, ts, val, stateAttributeValue) +func (mb *MetricsBuilder) RecordSystemMemoryUsageDataPoint(ts pcommon.Timestamp, val int64, stateAttributeValue AttributeState) { + mb.metricSystemMemoryUsage.recordDataPoint(mb.startTime, ts, val, stateAttributeValue.String()) } // RecordSystemMemoryUtilizationDataPoint adds a data point to system.memory.utilization metric. -func (mb *MetricsBuilder) RecordSystemMemoryUtilizationDataPoint(ts pcommon.Timestamp, val float64, stateAttributeValue string) { - mb.metricSystemMemoryUtilization.recordDataPoint(mb.startTime, ts, val, stateAttributeValue) +func (mb *MetricsBuilder) RecordSystemMemoryUtilizationDataPoint(ts pcommon.Timestamp, val float64, stateAttributeValue AttributeState) { + mb.metricSystemMemoryUtilization.recordDataPoint(mb.startTime, ts, val, stateAttributeValue.String()) } // Reset resets metrics builder to its initial state. It should be used when external metrics source is restarted, @@ -244,22 +290,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeState are the possible values that the attribute "state" can have. -var AttributeState = struct { - Buffered string - Cached string - Inactive string - Free string - SlabReclaimable string - SlabUnreclaimable string - Used string -}{ - "buffered", - "cached", - "inactive", - "free", - "slab_reclaimable", - "slab_unreclaimable", - "used", -} diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_linux.go b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_linux.go index 757936c9c5fb..1493a2d15396 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_linux.go +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_linux.go @@ -25,19 +25,19 @@ import ( ) func (s *scraper) recordMemoryUsageMetric(now pcommon.Timestamp, memInfo *mem.VirtualMemoryStat) { - s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Used), metadata.AttributeState.Used) - s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Free), metadata.AttributeState.Free) - s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Buffers), metadata.AttributeState.Buffered) - s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Cached), metadata.AttributeState.Cached) - s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Sreclaimable), metadata.AttributeState.SlabReclaimable) - s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Sunreclaim), metadata.AttributeState.SlabUnreclaimable) + s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Used), metadata.AttributeStateUsed) + s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Free), metadata.AttributeStateFree) + s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Buffers), metadata.AttributeStateBuffered) + s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Cached), metadata.AttributeStateCached) + s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Sreclaimable), metadata.AttributeStateSlabReclaimable) + s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Sunreclaim), metadata.AttributeStateSlabUnreclaimable) } func (s *scraper) recordMemoryUtilizationMetric(now pcommon.Timestamp, memInfo *mem.VirtualMemoryStat) { - s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Used)/float64(memInfo.Total), metadata.AttributeState.Used) - s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Free)/float64(memInfo.Total), metadata.AttributeState.Free) - s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Buffers)/float64(memInfo.Total), metadata.AttributeState.Buffered) - s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Cached)/float64(memInfo.Total), metadata.AttributeState.Cached) - s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Sreclaimable)/float64(memInfo.Total), metadata.AttributeState.SlabReclaimable) - s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Sunreclaim)/float64(memInfo.Total), metadata.AttributeState.SlabUnreclaimable) + s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Used)/float64(memInfo.Total), metadata.AttributeStateUsed) + s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Free)/float64(memInfo.Total), metadata.AttributeStateFree) + s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Buffers)/float64(memInfo.Total), metadata.AttributeStateBuffered) + s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Cached)/float64(memInfo.Total), metadata.AttributeStateCached) + s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Sreclaimable)/float64(memInfo.Total), metadata.AttributeStateSlabReclaimable) + s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Sunreclaim)/float64(memInfo.Total), metadata.AttributeStateSlabUnreclaimable) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_others.go b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_others.go index e9ccb0b02ba3..290de5431a0c 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_others.go +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_others.go @@ -25,13 +25,13 @@ import ( ) func (s *scraper) recordMemoryUsageMetric(now pcommon.Timestamp, memInfo *mem.VirtualMemoryStat) { - s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Used), metadata.AttributeState.Used) - s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Free), metadata.AttributeState.Free) - s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Inactive), metadata.AttributeState.Inactive) + s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Used), metadata.AttributeStateUsed) + s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Free), metadata.AttributeStateFree) + s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Inactive), metadata.AttributeStateInactive) } func (s *scraper) recordMemoryUtilizationMetric(now pcommon.Timestamp, memInfo *mem.VirtualMemoryStat) { - s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Used)/float64(memInfo.Total), metadata.AttributeState.Used) - s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Free)/float64(memInfo.Total), metadata.AttributeState.Free) - s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Inactive)/float64(memInfo.Total), metadata.AttributeState.Inactive) + s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Used)/float64(memInfo.Total), metadata.AttributeStateUsed) + s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Free)/float64(memInfo.Total), metadata.AttributeStateFree) + s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Inactive)/float64(memInfo.Total), metadata.AttributeStateInactive) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_test.go b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_test.go index 4dbf38ac3a05..74244c35b3a6 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_test.go @@ -123,7 +123,8 @@ func TestScrape(t *testing.T) { if runtime.GOOS == "linux" { assertMemoryUsageMetricHasLinuxSpecificStateLabels(t, metrics.At(0)) } else if runtime.GOOS != "windows" { - internal.AssertSumMetricHasAttributeValue(t, metrics.At(0), 2, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Inactive)) + internal.AssertSumMetricHasAttributeValue(t, metrics.At(0), 2, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateInactive.String())) } internal.AssertSameTimeStampForAllMetrics(t, metrics) @@ -178,7 +179,8 @@ func TestScrape_MemoryUtilization(t *testing.T) { if runtime.GOOS == "linux" { assertMemoryUtilizationMetricHasLinuxSpecificStateLabels(t, metrics.At(0)) } else if runtime.GOOS != "windows" { - internal.AssertGaugeMetricHasAttributeValue(t, metrics.At(0), 2, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Inactive)) + internal.AssertGaugeMetricHasAttributeValue(t, metrics.At(0), 2, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateInactive.String())) } internal.AssertSameTimeStampForAllMetrics(t, metrics) @@ -189,27 +191,39 @@ func TestScrape_MemoryUtilization(t *testing.T) { func assertMemoryUsageMetricValid(t *testing.T, metric pmetric.Metric, expectedName string) { assert.Equal(t, expectedName, metric.Name()) assert.GreaterOrEqual(t, metric.Sum().DataPoints().Len(), 2) - internal.AssertSumMetricHasAttributeValue(t, metric, 0, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Used)) - internal.AssertSumMetricHasAttributeValue(t, metric, 1, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Free)) + internal.AssertSumMetricHasAttributeValue(t, metric, 0, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateUsed.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 1, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateFree.String())) } func assertMemoryUtilizationMetricValid(t *testing.T, metric pmetric.Metric, expectedName string) { assert.Equal(t, expectedName, metric.Name()) assert.GreaterOrEqual(t, metric.Gauge().DataPoints().Len(), 2) - internal.AssertGaugeMetricHasAttributeValue(t, metric, 0, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Used)) - internal.AssertGaugeMetricHasAttributeValue(t, metric, 1, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Free)) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 0, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateUsed.String())) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 1, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateFree.String())) } func assertMemoryUsageMetricHasLinuxSpecificStateLabels(t *testing.T, metric pmetric.Metric) { - internal.AssertSumMetricHasAttributeValue(t, metric, 2, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Buffered)) - internal.AssertSumMetricHasAttributeValue(t, metric, 3, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Cached)) - internal.AssertSumMetricHasAttributeValue(t, metric, 4, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.SlabReclaimable)) - internal.AssertSumMetricHasAttributeValue(t, metric, 5, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.SlabUnreclaimable)) + internal.AssertSumMetricHasAttributeValue(t, metric, 2, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateBuffered.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 3, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateCached.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 4, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateSlabReclaimable.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 5, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateSlabUnreclaimable.String())) } func assertMemoryUtilizationMetricHasLinuxSpecificStateLabels(t *testing.T, metric pmetric.Metric) { - internal.AssertGaugeMetricHasAttributeValue(t, metric, 2, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Buffered)) - internal.AssertGaugeMetricHasAttributeValue(t, metric, 3, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.Cached)) - internal.AssertGaugeMetricHasAttributeValue(t, metric, 4, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.SlabReclaimable)) - internal.AssertGaugeMetricHasAttributeValue(t, metric, 5, metadata.Attributes.State, pcommon.NewValueString(metadata.AttributeState.SlabUnreclaimable)) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 2, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateBuffered.String())) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 3, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateCached.String())) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 4, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateSlabReclaimable.String())) + internal.AssertGaugeMetricHasAttributeValue(t, metric, 5, metadata.Attributes.State, + pcommon.NewValueString(metadata.AttributeStateSlabUnreclaimable.String())) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_windows.go b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_windows.go index 3579b6517906..08d4ee16a1ca 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_windows.go +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_windows.go @@ -25,11 +25,11 @@ import ( ) func (s *scraper) recordMemoryUsageMetric(now pcommon.Timestamp, memInfo *mem.VirtualMemoryStat) { - s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Used), metadata.AttributeState.Used) - s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Free), metadata.AttributeState.Free) + s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Used), metadata.AttributeStateUsed) + s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Free), metadata.AttributeStateFree) } func (s *scraper) recordMemoryUtilizationMetric(now pcommon.Timestamp, memInfo *mem.VirtualMemoryStat) { - s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Used)/float64(memInfo.Total), metadata.AttributeState.Used) - s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Free)/float64(memInfo.Total), metadata.AttributeState.Free) + s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Used)/float64(memInfo.Total), metadata.AttributeStateUsed) + s.mb.RecordSystemMemoryUtilizationDataPoint(now, float64(memInfo.Free)/float64(memInfo.Total), metadata.AttributeStateFree) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/internal/metadata/generated_metrics_v2.go b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/internal/metadata/generated_metrics_v2.go index 5e9b4176b7f0..b15c7791d78b 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/internal/metadata/generated_metrics_v2.go +++ b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/internal/metadata/generated_metrics_v2.go @@ -44,6 +44,54 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeDirection specifies the a value direction attribute. +type AttributeDirection int + +const ( + _ AttributeDirection = iota + AttributeDirectionReceive + AttributeDirectionTransmit +) + +// String returns the string representation of the AttributeDirection. +func (av AttributeDirection) String() string { + switch av { + case AttributeDirectionReceive: + return "receive" + case AttributeDirectionTransmit: + return "transmit" + } + return "" +} + +// MapAttributeDirection is a helper map of string to AttributeDirection attribute value. +var MapAttributeDirection = map[string]AttributeDirection{ + "receive": AttributeDirectionReceive, + "transmit": AttributeDirectionTransmit, +} + +// AttributeProtocol specifies the a value protocol attribute. +type AttributeProtocol int + +const ( + _ AttributeProtocol = iota + AttributeProtocolTcp +) + +// String returns the string representation of the AttributeProtocol. +func (av AttributeProtocol) String() string { + switch av { + case AttributeProtocolTcp: + return "tcp" + } + return "" +} + +// MapAttributeProtocol is a helper map of string to AttributeProtocol attribute value. +var MapAttributeProtocol = map[string]AttributeProtocol{ + "tcp": AttributeProtocolTcp, +} + type metricSystemNetworkConnections struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -403,28 +451,28 @@ func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pmetric.Metrics { } // RecordSystemNetworkConnectionsDataPoint adds a data point to system.network.connections metric. -func (mb *MetricsBuilder) RecordSystemNetworkConnectionsDataPoint(ts pcommon.Timestamp, val int64, protocolAttributeValue string, stateAttributeValue string) { - mb.metricSystemNetworkConnections.recordDataPoint(mb.startTime, ts, val, protocolAttributeValue, stateAttributeValue) +func (mb *MetricsBuilder) RecordSystemNetworkConnectionsDataPoint(ts pcommon.Timestamp, val int64, protocolAttributeValue AttributeProtocol, stateAttributeValue string) { + mb.metricSystemNetworkConnections.recordDataPoint(mb.startTime, ts, val, protocolAttributeValue.String(), stateAttributeValue) } // RecordSystemNetworkDroppedDataPoint adds a data point to system.network.dropped metric. -func (mb *MetricsBuilder) RecordSystemNetworkDroppedDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue string) { - mb.metricSystemNetworkDropped.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue) +func (mb *MetricsBuilder) RecordSystemNetworkDroppedDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue AttributeDirection) { + mb.metricSystemNetworkDropped.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue.String()) } // RecordSystemNetworkErrorsDataPoint adds a data point to system.network.errors metric. -func (mb *MetricsBuilder) RecordSystemNetworkErrorsDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue string) { - mb.metricSystemNetworkErrors.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue) +func (mb *MetricsBuilder) RecordSystemNetworkErrorsDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue AttributeDirection) { + mb.metricSystemNetworkErrors.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue.String()) } // RecordSystemNetworkIoDataPoint adds a data point to system.network.io metric. -func (mb *MetricsBuilder) RecordSystemNetworkIoDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue string) { - mb.metricSystemNetworkIo.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue) +func (mb *MetricsBuilder) RecordSystemNetworkIoDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue AttributeDirection) { + mb.metricSystemNetworkIo.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue.String()) } // RecordSystemNetworkPacketsDataPoint adds a data point to system.network.packets metric. -func (mb *MetricsBuilder) RecordSystemNetworkPacketsDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue string) { - mb.metricSystemNetworkPackets.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue) +func (mb *MetricsBuilder) RecordSystemNetworkPacketsDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue AttributeDirection) { + mb.metricSystemNetworkPackets.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue.String()) } // Reset resets metrics builder to its initial state. It should be used when external metrics source is restarted, @@ -455,19 +503,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeDirection are the possible values that the attribute "direction" can have. -var AttributeDirection = struct { - Receive string - Transmit string -}{ - "receive", - "transmit", -} - -// AttributeProtocol are the possible values that the attribute "protocol" can have. -var AttributeProtocol = struct { - Tcp string -}{ - "tcp", -} diff --git a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper.go b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper.go index 9a0b3084f162..eb117b6c720b 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper.go +++ b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper.go @@ -123,29 +123,29 @@ func (s *scraper) recordNetworkCounterMetrics() error { func (s *scraper) recordNetworkPacketsMetric(now pcommon.Timestamp, ioCountersSlice []net.IOCountersStat) { for _, ioCounters := range ioCountersSlice { - s.mb.RecordSystemNetworkPacketsDataPoint(now, int64(ioCounters.PacketsSent), ioCounters.Name, metadata.AttributeDirection.Transmit) - s.mb.RecordSystemNetworkPacketsDataPoint(now, int64(ioCounters.PacketsRecv), ioCounters.Name, metadata.AttributeDirection.Receive) + s.mb.RecordSystemNetworkPacketsDataPoint(now, int64(ioCounters.PacketsSent), ioCounters.Name, metadata.AttributeDirectionTransmit) + s.mb.RecordSystemNetworkPacketsDataPoint(now, int64(ioCounters.PacketsRecv), ioCounters.Name, metadata.AttributeDirectionReceive) } } func (s *scraper) recordNetworkDroppedPacketsMetric(now pcommon.Timestamp, ioCountersSlice []net.IOCountersStat) { for _, ioCounters := range ioCountersSlice { - s.mb.RecordSystemNetworkDroppedDataPoint(now, int64(ioCounters.Dropout), ioCounters.Name, metadata.AttributeDirection.Transmit) - s.mb.RecordSystemNetworkDroppedDataPoint(now, int64(ioCounters.Dropin), ioCounters.Name, metadata.AttributeDirection.Receive) + s.mb.RecordSystemNetworkDroppedDataPoint(now, int64(ioCounters.Dropout), ioCounters.Name, metadata.AttributeDirectionTransmit) + s.mb.RecordSystemNetworkDroppedDataPoint(now, int64(ioCounters.Dropin), ioCounters.Name, metadata.AttributeDirectionReceive) } } func (s *scraper) recordNetworkErrorPacketsMetric(now pcommon.Timestamp, ioCountersSlice []net.IOCountersStat) { for _, ioCounters := range ioCountersSlice { - s.mb.RecordSystemNetworkErrorsDataPoint(now, int64(ioCounters.Errout), ioCounters.Name, metadata.AttributeDirection.Transmit) - s.mb.RecordSystemNetworkErrorsDataPoint(now, int64(ioCounters.Errin), ioCounters.Name, metadata.AttributeDirection.Receive) + s.mb.RecordSystemNetworkErrorsDataPoint(now, int64(ioCounters.Errout), ioCounters.Name, metadata.AttributeDirectionTransmit) + s.mb.RecordSystemNetworkErrorsDataPoint(now, int64(ioCounters.Errin), ioCounters.Name, metadata.AttributeDirectionReceive) } } func (s *scraper) recordNetworkIOMetric(now pcommon.Timestamp, ioCountersSlice []net.IOCountersStat) { for _, ioCounters := range ioCountersSlice { - s.mb.RecordSystemNetworkIoDataPoint(now, int64(ioCounters.BytesSent), ioCounters.Name, metadata.AttributeDirection.Transmit) - s.mb.RecordSystemNetworkIoDataPoint(now, int64(ioCounters.BytesRecv), ioCounters.Name, metadata.AttributeDirection.Receive) + s.mb.RecordSystemNetworkIoDataPoint(now, int64(ioCounters.BytesSent), ioCounters.Name, metadata.AttributeDirectionTransmit) + s.mb.RecordSystemNetworkIoDataPoint(now, int64(ioCounters.BytesRecv), ioCounters.Name, metadata.AttributeDirectionReceive) } } @@ -177,7 +177,7 @@ func getTCPConnectionStatusCounts(connections []net.ConnectionStat) map[string]i func (s *scraper) recordNetworkConnectionsMetric(now pcommon.Timestamp, connectionStateCounts map[string]int64) { for connectionState, count := range connectionStateCounts { - s.mb.RecordSystemNetworkConnectionsDataPoint(now, count, metadata.AttributeProtocol.Tcp, connectionState) + s.mb.RecordSystemNetworkConnectionsDataPoint(now, count, metadata.AttributeProtocolTcp, connectionState) } } diff --git a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper_test.go b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper_test.go index 9b57f62d7f8a..7e6876ccea00 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper_test.go @@ -178,13 +178,16 @@ func assertNetworkIOMetricValid(t *testing.T, metric pmetric.Metric, expectedNam } assert.GreaterOrEqual(t, metric.Sum().DataPoints().Len(), 2) internal.AssertSumMetricHasAttribute(t, metric, 0, "device") - internal.AssertSumMetricHasAttributeValue(t, metric, 0, "direction", pcommon.NewValueString(metadata.AttributeDirection.Transmit)) - internal.AssertSumMetricHasAttributeValue(t, metric, 1, "direction", pcommon.NewValueString(metadata.AttributeDirection.Receive)) + internal.AssertSumMetricHasAttributeValue(t, metric, 0, "direction", + pcommon.NewValueString(metadata.AttributeDirectionTransmit.String())) + internal.AssertSumMetricHasAttributeValue(t, metric, 1, "direction", + pcommon.NewValueString(metadata.AttributeDirectionReceive.String())) } func assertNetworkConnectionsMetricValid(t *testing.T, metric pmetric.Metric) { assert.Equal(t, metric.Name(), "system.network.connections") - internal.AssertSumMetricHasAttributeValue(t, metric, 0, "protocol", pcommon.NewValueString(metadata.AttributeProtocol.Tcp)) + internal.AssertSumMetricHasAttributeValue(t, metric, 0, "protocol", + pcommon.NewValueString(metadata.AttributeProtocolTcp.String())) internal.AssertSumMetricHasAttribute(t, metric, 0, "state") assert.Equal(t, 12, metric.Sum().DataPoints().Len()) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/internal/metadata/generated_metrics_v2.go b/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/internal/metadata/generated_metrics_v2.go index 3c9bcc241f75..d452d60ce556 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/internal/metadata/generated_metrics_v2.go +++ b/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/internal/metadata/generated_metrics_v2.go @@ -40,6 +40,88 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeDirection specifies the a value direction attribute. +type AttributeDirection int + +const ( + _ AttributeDirection = iota + AttributeDirectionPageIn + AttributeDirectionPageOut +) + +// String returns the string representation of the AttributeDirection. +func (av AttributeDirection) String() string { + switch av { + case AttributeDirectionPageIn: + return "page_in" + case AttributeDirectionPageOut: + return "page_out" + } + return "" +} + +// MapAttributeDirection is a helper map of string to AttributeDirection attribute value. +var MapAttributeDirection = map[string]AttributeDirection{ + "page_in": AttributeDirectionPageIn, + "page_out": AttributeDirectionPageOut, +} + +// AttributeState specifies the a value state attribute. +type AttributeState int + +const ( + _ AttributeState = iota + AttributeStateCached + AttributeStateFree + AttributeStateUsed +) + +// String returns the string representation of the AttributeState. +func (av AttributeState) String() string { + switch av { + case AttributeStateCached: + return "cached" + case AttributeStateFree: + return "free" + case AttributeStateUsed: + return "used" + } + return "" +} + +// MapAttributeState is a helper map of string to AttributeState attribute value. +var MapAttributeState = map[string]AttributeState{ + "cached": AttributeStateCached, + "free": AttributeStateFree, + "used": AttributeStateUsed, +} + +// AttributeType specifies the a value type attribute. +type AttributeType int + +const ( + _ AttributeType = iota + AttributeTypeMajor + AttributeTypeMinor +) + +// String returns the string representation of the AttributeType. +func (av AttributeType) String() string { + switch av { + case AttributeTypeMajor: + return "major" + case AttributeTypeMinor: + return "minor" + } + return "" +} + +// MapAttributeType is a helper map of string to AttributeType attribute value. +var MapAttributeType = map[string]AttributeType{ + "major": AttributeTypeMajor, + "minor": AttributeTypeMinor, +} + type metricSystemPagingFaults struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -339,23 +421,23 @@ func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pmetric.Metrics { } // RecordSystemPagingFaultsDataPoint adds a data point to system.paging.faults metric. -func (mb *MetricsBuilder) RecordSystemPagingFaultsDataPoint(ts pcommon.Timestamp, val int64, typeAttributeValue string) { - mb.metricSystemPagingFaults.recordDataPoint(mb.startTime, ts, val, typeAttributeValue) +func (mb *MetricsBuilder) RecordSystemPagingFaultsDataPoint(ts pcommon.Timestamp, val int64, typeAttributeValue AttributeType) { + mb.metricSystemPagingFaults.recordDataPoint(mb.startTime, ts, val, typeAttributeValue.String()) } // RecordSystemPagingOperationsDataPoint adds a data point to system.paging.operations metric. -func (mb *MetricsBuilder) RecordSystemPagingOperationsDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue string, typeAttributeValue string) { - mb.metricSystemPagingOperations.recordDataPoint(mb.startTime, ts, val, directionAttributeValue, typeAttributeValue) +func (mb *MetricsBuilder) RecordSystemPagingOperationsDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue AttributeDirection, typeAttributeValue AttributeType) { + mb.metricSystemPagingOperations.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String(), typeAttributeValue.String()) } // RecordSystemPagingUsageDataPoint adds a data point to system.paging.usage metric. -func (mb *MetricsBuilder) RecordSystemPagingUsageDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, stateAttributeValue string) { - mb.metricSystemPagingUsage.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, stateAttributeValue) +func (mb *MetricsBuilder) RecordSystemPagingUsageDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, stateAttributeValue AttributeState) { + mb.metricSystemPagingUsage.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, stateAttributeValue.String()) } // RecordSystemPagingUtilizationDataPoint adds a data point to system.paging.utilization metric. -func (mb *MetricsBuilder) RecordSystemPagingUtilizationDataPoint(ts pcommon.Timestamp, val float64, deviceAttributeValue string, stateAttributeValue string) { - mb.metricSystemPagingUtilization.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, stateAttributeValue) +func (mb *MetricsBuilder) RecordSystemPagingUtilizationDataPoint(ts pcommon.Timestamp, val float64, deviceAttributeValue string, stateAttributeValue AttributeState) { + mb.metricSystemPagingUtilization.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, stateAttributeValue.String()) } // Reset resets metrics builder to its initial state. It should be used when external metrics source is restarted, @@ -386,32 +468,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeDirection are the possible values that the attribute "direction" can have. -var AttributeDirection = struct { - PageIn string - PageOut string -}{ - "page_in", - "page_out", -} - -// AttributeState are the possible values that the attribute "state" can have. -var AttributeState = struct { - Cached string - Free string - Used string -}{ - "cached", - "free", - "used", -} - -// AttributeType are the possible values that the attribute "type" can have. -var AttributeType = struct { - Major string - Minor string -}{ - "major", - "minor", -} diff --git a/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/paging_scraper_others.go b/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/paging_scraper_others.go index 105ca56d24c5..a4539284310e 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/paging_scraper_others.go +++ b/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/paging_scraper_others.go @@ -93,20 +93,20 @@ func (s *scraper) scrapePagingUsageMetric() error { func (s *scraper) recordPagingUsageDataPoints(now pcommon.Timestamp, pageFileStats []*pageFileStats) { for _, pageFile := range pageFileStats { - s.mb.RecordSystemPagingUsageDataPoint(now, int64(pageFile.usedBytes), pageFile.deviceName, metadata.AttributeState.Used) - s.mb.RecordSystemPagingUsageDataPoint(now, int64(pageFile.freeBytes), pageFile.deviceName, metadata.AttributeState.Free) + s.mb.RecordSystemPagingUsageDataPoint(now, int64(pageFile.usedBytes), pageFile.deviceName, metadata.AttributeStateUsed) + s.mb.RecordSystemPagingUsageDataPoint(now, int64(pageFile.freeBytes), pageFile.deviceName, metadata.AttributeStateFree) if pageFile.cachedBytes != nil { - s.mb.RecordSystemPagingUsageDataPoint(now, int64(*pageFile.cachedBytes), pageFile.deviceName, metadata.AttributeState.Cached) + s.mb.RecordSystemPagingUsageDataPoint(now, int64(*pageFile.cachedBytes), pageFile.deviceName, metadata.AttributeStateCached) } } } func (s *scraper) recordPagingUtilizationDataPoints(now pcommon.Timestamp, pageFileStats []*pageFileStats) { for _, pageFile := range pageFileStats { - s.mb.RecordSystemPagingUtilizationDataPoint(now, float64(pageFile.usedBytes)/float64(pageFile.totalBytes), pageFile.deviceName, metadata.AttributeState.Used) - s.mb.RecordSystemPagingUtilizationDataPoint(now, float64(pageFile.freeBytes)/float64(pageFile.totalBytes), pageFile.deviceName, metadata.AttributeState.Free) + s.mb.RecordSystemPagingUtilizationDataPoint(now, float64(pageFile.usedBytes)/float64(pageFile.totalBytes), pageFile.deviceName, metadata.AttributeStateUsed) + s.mb.RecordSystemPagingUtilizationDataPoint(now, float64(pageFile.freeBytes)/float64(pageFile.totalBytes), pageFile.deviceName, metadata.AttributeStateFree) if pageFile.cachedBytes != nil { - s.mb.RecordSystemPagingUtilizationDataPoint(now, float64(*pageFile.cachedBytes)/float64(pageFile.totalBytes), pageFile.deviceName, metadata.AttributeState.Cached) + s.mb.RecordSystemPagingUtilizationDataPoint(now, float64(*pageFile.cachedBytes)/float64(pageFile.totalBytes), pageFile.deviceName, metadata.AttributeStateCached) } } } @@ -124,13 +124,13 @@ func (s *scraper) scrapePagingMetrics() error { } func (s *scraper) recordPagingOperationsDataPoints(now pcommon.Timestamp, swap *mem.SwapMemoryStat) { - s.mb.RecordSystemPagingOperationsDataPoint(now, int64(swap.Sin), metadata.AttributeDirection.PageIn, metadata.AttributeType.Major) - s.mb.RecordSystemPagingOperationsDataPoint(now, int64(swap.Sout), metadata.AttributeDirection.PageOut, metadata.AttributeType.Major) - s.mb.RecordSystemPagingOperationsDataPoint(now, int64(swap.PgIn), metadata.AttributeDirection.PageIn, metadata.AttributeType.Minor) - s.mb.RecordSystemPagingOperationsDataPoint(now, int64(swap.PgOut), metadata.AttributeDirection.PageOut, metadata.AttributeType.Minor) + s.mb.RecordSystemPagingOperationsDataPoint(now, int64(swap.Sin), metadata.AttributeDirectionPageIn, metadata.AttributeTypeMajor) + s.mb.RecordSystemPagingOperationsDataPoint(now, int64(swap.Sout), metadata.AttributeDirectionPageOut, metadata.AttributeTypeMajor) + s.mb.RecordSystemPagingOperationsDataPoint(now, int64(swap.PgIn), metadata.AttributeDirectionPageIn, metadata.AttributeTypeMinor) + s.mb.RecordSystemPagingOperationsDataPoint(now, int64(swap.PgOut), metadata.AttributeDirectionPageOut, metadata.AttributeTypeMinor) } func (s *scraper) recordPageFaultsDataPoints(now pcommon.Timestamp, swap *mem.SwapMemoryStat) { - s.mb.RecordSystemPagingFaultsDataPoint(now, int64(swap.PgMajFault), metadata.AttributeType.Major) - s.mb.RecordSystemPagingFaultsDataPoint(now, int64(swap.PgFault-swap.PgMajFault), metadata.AttributeType.Minor) + s.mb.RecordSystemPagingFaultsDataPoint(now, int64(swap.PgMajFault), metadata.AttributeTypeMajor) + s.mb.RecordSystemPagingFaultsDataPoint(now, int64(swap.PgFault-swap.PgMajFault), metadata.AttributeTypeMinor) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/paging_scraper_test.go b/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/paging_scraper_test.go index 68e078d1df27..f656961d6130 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/paging_scraper_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/paging_scraper_test.go @@ -125,11 +125,14 @@ func assertPagingUsageMetricValid(t *testing.T, hostPagingUsageMetric pmetric.Me } assert.GreaterOrEqual(t, hostPagingUsageMetric.Sum().DataPoints().Len(), expectedDataPoints) - internal.AssertSumMetricHasAttributeValue(t, hostPagingUsageMetric, 0, "state", pcommon.NewValueString(metadata.AttributeState.Used)) - internal.AssertSumMetricHasAttributeValue(t, hostPagingUsageMetric, 1, "state", pcommon.NewValueString(metadata.AttributeState.Free)) + internal.AssertSumMetricHasAttributeValue(t, hostPagingUsageMetric, 0, "state", + pcommon.NewValueString(metadata.AttributeStateUsed.String())) + internal.AssertSumMetricHasAttributeValue(t, hostPagingUsageMetric, 1, "state", + pcommon.NewValueString(metadata.AttributeStateFree.String())) // Windows and Linux do not support cached state label if runtime.GOOS != "windows" && runtime.GOOS != "linux" { - internal.AssertSumMetricHasAttributeValue(t, hostPagingUsageMetric, 2, "state", pcommon.NewValueString(metadata.AttributeState.Cached)) + internal.AssertSumMetricHasAttributeValue(t, hostPagingUsageMetric, 2, "state", + pcommon.NewValueString(metadata.AttributeStateCached.String())) } // on Windows and Linux, also expect the page file device name label @@ -160,11 +163,14 @@ func assertPagingUtilizationMetricValid(t *testing.T, hostPagingUtilizationMetri } assert.GreaterOrEqual(t, hostPagingUtilizationMetric.Gauge().DataPoints().Len(), expectedDataPoints) - internal.AssertGaugeMetricHasAttributeValue(t, hostPagingUtilizationMetric, 0, "state", pcommon.NewValueString(metadata.AttributeState.Used)) - internal.AssertGaugeMetricHasAttributeValue(t, hostPagingUtilizationMetric, 1, "state", pcommon.NewValueString(metadata.AttributeState.Free)) + internal.AssertGaugeMetricHasAttributeValue(t, hostPagingUtilizationMetric, 0, "state", + pcommon.NewValueString(metadata.AttributeStateUsed.String())) + internal.AssertGaugeMetricHasAttributeValue(t, hostPagingUtilizationMetric, 1, "state", + pcommon.NewValueString(metadata.AttributeStateFree.String())) // Windows and Linux do not support cached state label if runtime.GOOS != "windows" && runtime.GOOS != "linux" { - internal.AssertGaugeMetricHasAttributeValue(t, hostPagingUtilizationMetric, 2, "state", pcommon.NewValueString(metadata.AttributeState.Cached)) + internal.AssertGaugeMetricHasAttributeValue(t, hostPagingUtilizationMetric, 2, "state", + pcommon.NewValueString(metadata.AttributeStateCached.String())) } // on Windows and Linux, also expect the page file device name label @@ -193,15 +199,23 @@ func assertPagingOperationsMetricValid(t *testing.T, pagingMetric pmetric.Metric } assert.Equal(t, expectedDataPoints, pagingMetric.Sum().DataPoints().Len()) - internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 0, "type", pcommon.NewValueString(metadata.AttributeType.Major)) - internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 0, "direction", pcommon.NewValueString(metadata.AttributeDirection.PageIn)) - internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 1, "type", pcommon.NewValueString(metadata.AttributeType.Major)) - internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 1, "direction", pcommon.NewValueString(metadata.AttributeDirection.PageOut)) + internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 0, "type", + pcommon.NewValueString(metadata.AttributeTypeMajor.String())) + internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 0, "direction", + pcommon.NewValueString(metadata.AttributeDirectionPageIn.String())) + internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 1, "type", + pcommon.NewValueString(metadata.AttributeTypeMajor.String())) + internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 1, "direction", + pcommon.NewValueString(metadata.AttributeDirectionPageOut.String())) if runtime.GOOS != "windows" { - internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 2, "type", pcommon.NewValueString(metadata.AttributeType.Minor)) - internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 2, "direction", pcommon.NewValueString(metadata.AttributeDirection.PageIn)) - internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 3, "type", pcommon.NewValueString(metadata.AttributeType.Minor)) - internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 3, "direction", pcommon.NewValueString(metadata.AttributeDirection.PageOut)) + internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 2, "type", + pcommon.NewValueString(metadata.AttributeTypeMinor.String())) + internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 2, "direction", + pcommon.NewValueString(metadata.AttributeDirectionPageIn.String())) + internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 3, "type", + pcommon.NewValueString(metadata.AttributeTypeMinor.String())) + internal.AssertSumMetricHasAttributeValue(t, pagingMetric, 3, "direction", + pcommon.NewValueString(metadata.AttributeDirectionPageOut.String())) } } @@ -218,6 +232,8 @@ func assertPageFaultsMetricValid(t *testing.T, pageFaultsMetric pmetric.Metric, } assert.Equal(t, 2, pageFaultsMetric.Sum().DataPoints().Len()) - internal.AssertSumMetricHasAttributeValue(t, pageFaultsMetric, 0, "type", pcommon.NewValueString(metadata.AttributeType.Major)) - internal.AssertSumMetricHasAttributeValue(t, pageFaultsMetric, 1, "type", pcommon.NewValueString(metadata.AttributeType.Minor)) + internal.AssertSumMetricHasAttributeValue(t, pageFaultsMetric, 0, "type", + pcommon.NewValueString(metadata.AttributeTypeMajor.String())) + internal.AssertSumMetricHasAttributeValue(t, pageFaultsMetric, 1, "type", + pcommon.NewValueString(metadata.AttributeTypeMinor.String())) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/paging_scraper_windows.go b/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/paging_scraper_windows.go index f36010a250aa..ab3d220e5884 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/paging_scraper_windows.go +++ b/receiver/hostmetricsreceiver/internal/scraper/pagingscraper/paging_scraper_windows.go @@ -101,15 +101,15 @@ func (s *scraper) scrapePagingUsageMetric() error { func (s *scraper) recordPagingUsageDataPoints(now pcommon.Timestamp, pageFiles []*pageFileStats) { for _, pageFile := range pageFiles { - s.mb.RecordSystemPagingUsageDataPoint(now, int64(pageFile.usedBytes), pageFile.deviceName, metadata.AttributeState.Used) - s.mb.RecordSystemPagingUsageDataPoint(now, int64(pageFile.freeBytes), pageFile.deviceName, metadata.AttributeState.Free) + s.mb.RecordSystemPagingUsageDataPoint(now, int64(pageFile.usedBytes), pageFile.deviceName, metadata.AttributeStateUsed) + s.mb.RecordSystemPagingUsageDataPoint(now, int64(pageFile.freeBytes), pageFile.deviceName, metadata.AttributeStateFree) } } func (s *scraper) recordPagingUtilizationDataPoints(now pcommon.Timestamp, pageFiles []*pageFileStats) { for _, pageFile := range pageFiles { - s.mb.RecordSystemPagingUtilizationDataPoint(now, float64(pageFile.usedBytes)/float64(pageFile.totalBytes), pageFile.deviceName, metadata.AttributeState.Used) - s.mb.RecordSystemPagingUtilizationDataPoint(now, float64(pageFile.freeBytes)/float64(pageFile.totalBytes), pageFile.deviceName, metadata.AttributeState.Free) + s.mb.RecordSystemPagingUtilizationDataPoint(now, float64(pageFile.usedBytes)/float64(pageFile.totalBytes), pageFile.deviceName, metadata.AttributeStateUsed) + s.mb.RecordSystemPagingUtilizationDataPoint(now, float64(pageFile.freeBytes)/float64(pageFile.totalBytes), pageFile.deviceName, metadata.AttributeStateFree) } } @@ -138,6 +138,6 @@ func (s *scraper) scrapePagingOperationsMetric() error { } func (s *scraper) recordPagingOperationsDataPoints(now pcommon.Timestamp, memoryCounterValues *perfcounters.CounterValues) { - s.mb.RecordSystemPagingOperationsDataPoint(now, memoryCounterValues.Values[pageReadsPerSec], metadata.AttributeDirection.PageIn, metadata.AttributeType.Major) - s.mb.RecordSystemPagingOperationsDataPoint(now, memoryCounterValues.Values[pageWritesPerSec], metadata.AttributeDirection.PageOut, metadata.AttributeType.Major) + s.mb.RecordSystemPagingOperationsDataPoint(now, memoryCounterValues.Values[pageReadsPerSec], metadata.AttributeDirectionPageIn, metadata.AttributeTypeMajor) + s.mb.RecordSystemPagingOperationsDataPoint(now, memoryCounterValues.Values[pageWritesPerSec], metadata.AttributeDirectionPageOut, metadata.AttributeTypeMajor) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata/generated_metrics_v2.go b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata/generated_metrics_v2.go index debd551c4a48..f262244f2086 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata/generated_metrics_v2.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata/generated_metrics_v2.go @@ -32,6 +32,76 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeStatus specifies the a value status attribute. +type AttributeStatus int + +const ( + _ AttributeStatus = iota + AttributeStatusBlocked + AttributeStatusDaemon + AttributeStatusDetached + AttributeStatusIdle + AttributeStatusLocked + AttributeStatusOrphan + AttributeStatusPaging + AttributeStatusRunning + AttributeStatusSleeping + AttributeStatusStopped + AttributeStatusSystem + AttributeStatusUnknown + AttributeStatusZombies +) + +// String returns the string representation of the AttributeStatus. +func (av AttributeStatus) String() string { + switch av { + case AttributeStatusBlocked: + return "blocked" + case AttributeStatusDaemon: + return "daemon" + case AttributeStatusDetached: + return "detached" + case AttributeStatusIdle: + return "idle" + case AttributeStatusLocked: + return "locked" + case AttributeStatusOrphan: + return "orphan" + case AttributeStatusPaging: + return "paging" + case AttributeStatusRunning: + return "running" + case AttributeStatusSleeping: + return "sleeping" + case AttributeStatusStopped: + return "stopped" + case AttributeStatusSystem: + return "system" + case AttributeStatusUnknown: + return "unknown" + case AttributeStatusZombies: + return "zombies" + } + return "" +} + +// MapAttributeStatus is a helper map of string to AttributeStatus attribute value. +var MapAttributeStatus = map[string]AttributeStatus{ + "blocked": AttributeStatusBlocked, + "daemon": AttributeStatusDaemon, + "detached": AttributeStatusDetached, + "idle": AttributeStatusIdle, + "locked": AttributeStatusLocked, + "orphan": AttributeStatusOrphan, + "paging": AttributeStatusPaging, + "running": AttributeStatusRunning, + "sleeping": AttributeStatusSleeping, + "stopped": AttributeStatusStopped, + "system": AttributeStatusSystem, + "unknown": AttributeStatusUnknown, + "zombies": AttributeStatusZombies, +} + type metricSystemProcessesCount struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -216,8 +286,8 @@ func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pmetric.Metrics { } // RecordSystemProcessesCountDataPoint adds a data point to system.processes.count metric. -func (mb *MetricsBuilder) RecordSystemProcessesCountDataPoint(ts pcommon.Timestamp, val int64, statusAttributeValue string) { - mb.metricSystemProcessesCount.recordDataPoint(mb.startTime, ts, val, statusAttributeValue) +func (mb *MetricsBuilder) RecordSystemProcessesCountDataPoint(ts pcommon.Timestamp, val int64, statusAttributeValue AttributeStatus) { + mb.metricSystemProcessesCount.recordDataPoint(mb.startTime, ts, val, statusAttributeValue.String()) } // RecordSystemProcessesCreatedDataPoint adds a data point to system.processes.created metric. @@ -244,34 +314,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeStatus are the possible values that the attribute "status" can have. -var AttributeStatus = struct { - Blocked string - Daemon string - Detached string - Idle string - Locked string - Orphan string - Paging string - Running string - Sleeping string - Stopped string - System string - Unknown string - Zombies string -}{ - "blocked", - "daemon", - "detached", - "idle", - "locked", - "orphan", - "paging", - "running", - "sleeping", - "stopped", - "system", - "unknown", - "zombies", -} diff --git a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper.go b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper.go index 4ae87ad7b060..1c921ee998f0 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper.go @@ -56,8 +56,8 @@ type proc interface { } type processesMetadata struct { - countByStatus map[string]int64 // ignored if enableProcessesCount is false - processesCreated *int64 // ignored if enableProcessesCreated is false + countByStatus map[metadata.AttributeStatus]int64 // ignored if enableProcessesCount is false + processesCreated *int64 // ignored if enableProcessesCreated is false } // newProcessesScraper creates a set of Processes related metrics diff --git a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper_test.go b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper_test.go index 58835e9b8af4..79d3b466d739 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper_test.go @@ -145,8 +145,8 @@ func validateRealData(t *testing.T, metrics pmetric.MetricSlice) { } assert.Failf("missing-metric", "metric is missing %q status label", statusVal) } - assertContainsStatus(metadata.AttributeStatus.Running) - assertContainsStatus(metadata.AttributeStatus.Blocked) + assertContainsStatus(metadata.AttributeStatusRunning.String()) + assertContainsStatus(metadata.AttributeStatusBlocked.String()) } if expectProcessesCreatedMetric { @@ -212,15 +212,14 @@ func validateFakeData(t *testing.T, metrics pmetric.MetricSlice) { attrs[val.StringVal()] = point.IntVal() } - ls := metadata.AttributeStatus assert.Equal(attrs, map[string]int64{ - ls.Blocked: 3, - ls.Paging: 1, - ls.Running: 2, - ls.Sleeping: 4, - ls.Stopped: 5, - ls.Unknown: 9, - ls.Zombies: 6, + metadata.AttributeStatusBlocked.String(): 3, + metadata.AttributeStatusPaging.String(): 1, + metadata.AttributeStatusRunning.String(): 2, + metadata.AttributeStatusSleeping.String(): 4, + metadata.AttributeStatusStopped.String(): 5, + metadata.AttributeStatusUnknown.String(): 9, + metadata.AttributeStatusZombies.String(): 6, }) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper_unix.go b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper_unix.go index bbd7c34e7ba3..0385fba6e89e 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper_unix.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper_unix.go @@ -34,7 +34,7 @@ func (s *scraper) getProcessesMetadata() (processesMetadata, error) { return processesMetadata{}, err } - countByStatus := map[string]int64{} + countByStatus := map[metadata.AttributeStatus]int64{} for _, process := range processes { var status []string status, err = process.Status() @@ -45,7 +45,7 @@ func (s *scraper) getProcessesMetadata() (processesMetadata, error) { } state, ok := toAttributeStatus(status) if !ok { - countByStatus[metadata.AttributeStatus.Unknown]++ + countByStatus[metadata.AttributeStatusUnknown]++ continue } countByStatus[state]++ @@ -65,15 +65,15 @@ func (s *scraper) getProcessesMetadata() (processesMetadata, error) { procsCreated = &v } - countByStatus[metadata.AttributeStatus.Blocked] = int64(miscStat.ProcsBlocked) - countByStatus[metadata.AttributeStatus.Running] = int64(miscStat.ProcsRunning) + countByStatus[metadata.AttributeStatusBlocked] = int64(miscStat.ProcsBlocked) + countByStatus[metadata.AttributeStatusRunning] = int64(miscStat.ProcsRunning) totalKnown := int64(0) for _, count := range countByStatus { totalKnown += count } if int64(miscStat.ProcsTotal) > totalKnown { - countByStatus[metadata.AttributeStatus.Unknown] = int64(miscStat.ProcsTotal) - totalKnown + countByStatus[metadata.AttributeStatusUnknown] = int64(miscStat.ProcsTotal) - totalKnown } return processesMetadata{ @@ -82,25 +82,25 @@ func (s *scraper) getProcessesMetadata() (processesMetadata, error) { }, nil } -func toAttributeStatus(status []string) (string, bool) { +func toAttributeStatus(status []string) (metadata.AttributeStatus, bool) { if len(status) == 0 || len(status[0]) == 0 { - return "", false + return metadata.AttributeStatus(0), false } state, ok := charToState[status[0]] return state, ok } -var charToState = map[string]string{ - process.Blocked: metadata.AttributeStatus.Blocked, - process.Daemon: metadata.AttributeStatus.Daemon, - process.Detached: metadata.AttributeStatus.Detached, - process.Idle: metadata.AttributeStatus.Idle, - process.Lock: metadata.AttributeStatus.Locked, - process.Orphan: metadata.AttributeStatus.Orphan, - process.Running: metadata.AttributeStatus.Running, - process.Sleep: metadata.AttributeStatus.Sleeping, - process.Stop: metadata.AttributeStatus.Stopped, - process.System: metadata.AttributeStatus.System, - process.Wait: metadata.AttributeStatus.Paging, - process.Zombie: metadata.AttributeStatus.Zombies, +var charToState = map[string]metadata.AttributeStatus{ + process.Blocked: metadata.AttributeStatusBlocked, + process.Daemon: metadata.AttributeStatusDaemon, + process.Detached: metadata.AttributeStatusDetached, + process.Idle: metadata.AttributeStatusIdle, + process.Lock: metadata.AttributeStatusLocked, + process.Orphan: metadata.AttributeStatusOrphan, + process.Running: metadata.AttributeStatusRunning, + process.Sleep: metadata.AttributeStatusSleeping, + process.Stop: metadata.AttributeStatusStopped, + process.System: metadata.AttributeStatusSystem, + process.Wait: metadata.AttributeStatusPaging, + process.Zombie: metadata.AttributeStatusZombies, } diff --git a/receiver/hostmetricsreceiver/internal/scraper/processscraper/internal/metadata/generated_metrics_v2.go b/receiver/hostmetricsreceiver/internal/scraper/processscraper/internal/metadata/generated_metrics_v2.go index 6d03c137617b..52a4da84fb8a 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processscraper/internal/metadata/generated_metrics_v2.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processscraper/internal/metadata/generated_metrics_v2.go @@ -40,6 +40,62 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeDirection specifies the a value direction attribute. +type AttributeDirection int + +const ( + _ AttributeDirection = iota + AttributeDirectionRead + AttributeDirectionWrite +) + +// String returns the string representation of the AttributeDirection. +func (av AttributeDirection) String() string { + switch av { + case AttributeDirectionRead: + return "read" + case AttributeDirectionWrite: + return "write" + } + return "" +} + +// MapAttributeDirection is a helper map of string to AttributeDirection attribute value. +var MapAttributeDirection = map[string]AttributeDirection{ + "read": AttributeDirectionRead, + "write": AttributeDirectionWrite, +} + +// AttributeState specifies the a value state attribute. +type AttributeState int + +const ( + _ AttributeState = iota + AttributeStateSystem + AttributeStateUser + AttributeStateWait +) + +// String returns the string representation of the AttributeState. +func (av AttributeState) String() string { + switch av { + case AttributeStateSystem: + return "system" + case AttributeStateUser: + return "user" + case AttributeStateWait: + return "wait" + } + return "" +} + +// MapAttributeState is a helper map of string to AttributeState attribute value. +var MapAttributeState = map[string]AttributeState{ + "system": AttributeStateSystem, + "user": AttributeStateUser, + "wait": AttributeStateWait, +} + type metricProcessCPUTime struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -376,13 +432,13 @@ func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pmetric.Metrics { } // RecordProcessCPUTimeDataPoint adds a data point to process.cpu.time metric. -func (mb *MetricsBuilder) RecordProcessCPUTimeDataPoint(ts pcommon.Timestamp, val float64, stateAttributeValue string) { - mb.metricProcessCPUTime.recordDataPoint(mb.startTime, ts, val, stateAttributeValue) +func (mb *MetricsBuilder) RecordProcessCPUTimeDataPoint(ts pcommon.Timestamp, val float64, stateAttributeValue AttributeState) { + mb.metricProcessCPUTime.recordDataPoint(mb.startTime, ts, val, stateAttributeValue.String()) } // RecordProcessDiskIoDataPoint adds a data point to process.disk.io metric. -func (mb *MetricsBuilder) RecordProcessDiskIoDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue string) { - mb.metricProcessDiskIo.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordProcessDiskIoDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue AttributeDirection) { + mb.metricProcessDiskIo.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordProcessMemoryPhysicalUsageDataPoint adds a data point to process.memory.physical_usage metric. @@ -417,23 +473,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeDirection are the possible values that the attribute "direction" can have. -var AttributeDirection = struct { - Read string - Write string -}{ - "read", - "write", -} - -// AttributeState are the possible values that the attribute "state" can have. -var AttributeState = struct { - System string - User string - Wait string -}{ - "system", - "user", - "wait", -} diff --git a/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper.go b/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper.go index 645fe8aed2a2..7a19e56a496a 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper.go @@ -198,7 +198,7 @@ func (s *scraper) scrapeAndAppendDiskIOMetric(now pcommon.Timestamp, handle proc return err } - s.mb.RecordProcessDiskIoDataPoint(now, int64(io.ReadBytes), metadata.AttributeDirection.Read) - s.mb.RecordProcessDiskIoDataPoint(now, int64(io.WriteBytes), metadata.AttributeDirection.Write) + s.mb.RecordProcessDiskIoDataPoint(now, int64(io.ReadBytes), metadata.AttributeDirectionRead) + s.mb.RecordProcessDiskIoDataPoint(now, int64(io.WriteBytes), metadata.AttributeDirectionWrite) return nil } diff --git a/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper_linux.go b/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper_linux.go index 6abca906e703..833834210431 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper_linux.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper_linux.go @@ -25,9 +25,9 @@ import ( ) func (s *scraper) recordCPUTimeMetric(now pcommon.Timestamp, cpuTime *cpu.TimesStat) { - s.mb.RecordProcessCPUTimeDataPoint(now, cpuTime.User, metadata.AttributeState.User) - s.mb.RecordProcessCPUTimeDataPoint(now, cpuTime.System, metadata.AttributeState.System) - s.mb.RecordProcessCPUTimeDataPoint(now, cpuTime.Iowait, metadata.AttributeState.Wait) + s.mb.RecordProcessCPUTimeDataPoint(now, cpuTime.User, metadata.AttributeStateUser) + s.mb.RecordProcessCPUTimeDataPoint(now, cpuTime.System, metadata.AttributeStateSystem) + s.mb.RecordProcessCPUTimeDataPoint(now, cpuTime.Iowait, metadata.AttributeStateWait) } func getProcessExecutable(proc processHandle) (*executableMetadata, error) { diff --git a/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper_test.go b/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper_test.go index 7636bb8e25db..a36e959a68b2 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper_test.go @@ -96,10 +96,13 @@ func assertCPUTimeMetricValid(t *testing.T, resourceMetrics pmetric.ResourceMetr if startTime != 0 { internal.AssertSumMetricStartTimeEquals(t, cpuTimeMetric, startTime) } - internal.AssertSumMetricHasAttributeValue(t, cpuTimeMetric, 0, "state", pcommon.NewValueString(metadata.AttributeState.User)) - internal.AssertSumMetricHasAttributeValue(t, cpuTimeMetric, 1, "state", pcommon.NewValueString(metadata.AttributeState.System)) + internal.AssertSumMetricHasAttributeValue(t, cpuTimeMetric, 0, "state", + pcommon.NewValueString(metadata.AttributeStateUser.String())) + internal.AssertSumMetricHasAttributeValue(t, cpuTimeMetric, 1, "state", + pcommon.NewValueString(metadata.AttributeStateSystem.String())) if runtime.GOOS == "linux" { - internal.AssertSumMetricHasAttributeValue(t, cpuTimeMetric, 2, "state", pcommon.NewValueString(metadata.AttributeState.Wait)) + internal.AssertSumMetricHasAttributeValue(t, cpuTimeMetric, 2, "state", + pcommon.NewValueString(metadata.AttributeStateWait.String())) } } @@ -121,8 +124,10 @@ func assertDiskIOMetricValid(t *testing.T, resourceMetrics pmetric.ResourceMetri if startTime != 0 { internal.AssertSumMetricStartTimeEquals(t, diskIOMetric, startTime) } - internal.AssertSumMetricHasAttributeValue(t, diskIOMetric, 0, "direction", pcommon.NewValueString(metadata.AttributeDirection.Read)) - internal.AssertSumMetricHasAttributeValue(t, diskIOMetric, 1, "direction", pcommon.NewValueString(metadata.AttributeDirection.Write)) + internal.AssertSumMetricHasAttributeValue(t, diskIOMetric, 0, "direction", + pcommon.NewValueString(metadata.AttributeDirectionRead.String())) + internal.AssertSumMetricHasAttributeValue(t, diskIOMetric, 1, "direction", + pcommon.NewValueString(metadata.AttributeDirectionWrite.String())) } func assertSameTimeStampForAllMetricsWithinResource(t *testing.T, resourceMetrics pmetric.ResourceMetricsSlice) { diff --git a/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper_windows.go b/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper_windows.go index 6f46b0d1bfa6..be6c3dc8361b 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper_windows.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processscraper/process_scraper_windows.go @@ -28,8 +28,8 @@ import ( ) func (s *scraper) recordCPUTimeMetric(now pcommon.Timestamp, cpuTime *cpu.TimesStat) { - s.mb.RecordProcessCPUTimeDataPoint(now, cpuTime.User, metadata.AttributeState.User) - s.mb.RecordProcessCPUTimeDataPoint(now, cpuTime.System, metadata.AttributeState.System) + s.mb.RecordProcessCPUTimeDataPoint(now, cpuTime.User, metadata.AttributeStateUser) + s.mb.RecordProcessCPUTimeDataPoint(now, cpuTime.System, metadata.AttributeStateSystem) } func getProcessExecutable(proc processHandle) (*executableMetadata, error) { diff --git a/receiver/iisreceiver/internal/metadata/generated_metrics_v2.go b/receiver/iisreceiver/internal/metadata/generated_metrics_v2.go index 173ea894d3fb..62a606738ee4 100644 --- a/receiver/iisreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/iisreceiver/internal/metadata/generated_metrics_v2.go @@ -71,6 +71,78 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeDirection specifies the a value direction attribute. +type AttributeDirection int + +const ( + _ AttributeDirection = iota + AttributeDirectionSent + AttributeDirectionReceived +) + +// String returns the string representation of the AttributeDirection. +func (av AttributeDirection) String() string { + switch av { + case AttributeDirectionSent: + return "sent" + case AttributeDirectionReceived: + return "received" + } + return "" +} + +// MapAttributeDirection is a helper map of string to AttributeDirection attribute value. +var MapAttributeDirection = map[string]AttributeDirection{ + "sent": AttributeDirectionSent, + "received": AttributeDirectionReceived, +} + +// AttributeRequest specifies the a value request attribute. +type AttributeRequest int + +const ( + _ AttributeRequest = iota + AttributeRequestDelete + AttributeRequestGet + AttributeRequestHead + AttributeRequestOptions + AttributeRequestPost + AttributeRequestPut + AttributeRequestTrace +) + +// String returns the string representation of the AttributeRequest. +func (av AttributeRequest) String() string { + switch av { + case AttributeRequestDelete: + return "delete" + case AttributeRequestGet: + return "get" + case AttributeRequestHead: + return "head" + case AttributeRequestOptions: + return "options" + case AttributeRequestPost: + return "post" + case AttributeRequestPut: + return "put" + case AttributeRequestTrace: + return "trace" + } + return "" +} + +// MapAttributeRequest is a helper map of string to AttributeRequest attribute value. +var MapAttributeRequest = map[string]AttributeRequest{ + "delete": AttributeRequestDelete, + "get": AttributeRequestGet, + "head": AttributeRequestHead, + "options": AttributeRequestOptions, + "post": AttributeRequestPost, + "put": AttributeRequestPut, + "trace": AttributeRequestTrace, +} + type metricIisConnectionActive struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -814,18 +886,18 @@ func (mb *MetricsBuilder) RecordIisNetworkBlockedDataPoint(ts pcommon.Timestamp, } // RecordIisNetworkFileCountDataPoint adds a data point to iis.network.file.count metric. -func (mb *MetricsBuilder) RecordIisNetworkFileCountDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue string) { - mb.metricIisNetworkFileCount.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordIisNetworkFileCountDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue AttributeDirection) { + mb.metricIisNetworkFileCount.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordIisNetworkIoDataPoint adds a data point to iis.network.io metric. -func (mb *MetricsBuilder) RecordIisNetworkIoDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue string) { - mb.metricIisNetworkIo.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordIisNetworkIoDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue AttributeDirection) { + mb.metricIisNetworkIo.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordIisRequestCountDataPoint adds a data point to iis.request.count metric. -func (mb *MetricsBuilder) RecordIisRequestCountDataPoint(ts pcommon.Timestamp, val int64, requestAttributeValue string) { - mb.metricIisRequestCount.recordDataPoint(mb.startTime, ts, val, requestAttributeValue) +func (mb *MetricsBuilder) RecordIisRequestCountDataPoint(ts pcommon.Timestamp, val int64, requestAttributeValue AttributeRequest) { + mb.metricIisRequestCount.recordDataPoint(mb.startTime, ts, val, requestAttributeValue.String()) } // RecordIisRequestQueueAgeMaxDataPoint adds a data point to iis.request.queue.age.max metric. @@ -875,31 +947,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeDirection are the possible values that the attribute "direction" can have. -var AttributeDirection = struct { - Sent string - Received string -}{ - "sent", - "received", -} - -// AttributeRequest are the possible values that the attribute "request" can have. -var AttributeRequest = struct { - Delete string - Get string - Head string - Options string - Post string - Put string - Trace string -}{ - "delete", - "get", - "head", - "options", - "post", - "put", - "trace", -} diff --git a/receiver/iisreceiver/internal/metadata/recorder.go b/receiver/iisreceiver/internal/metadata/recorder.go index 8d848530d09f..365f89090d7f 100644 --- a/receiver/iisreceiver/internal/metadata/recorder.go +++ b/receiver/iisreceiver/internal/metadata/recorder.go @@ -29,11 +29,11 @@ func (mb *MetricsBuilder) RecordAny(ts pcommon.Timestamp, val float64, name stri case "iis.network.blocked": mb.RecordIisNetworkBlockedDataPoint(ts, int64(val)) case "iis.network.file.count": - mb.RecordIisNetworkFileCountDataPoint(ts, int64(val), attributes[A.Direction]) + mb.RecordIisNetworkFileCountDataPoint(ts, int64(val), MapAttributeDirection[attributes[A.Direction]]) case "iis.network.io": - mb.RecordIisNetworkIoDataPoint(ts, int64(val), attributes[A.Direction]) + mb.RecordIisNetworkIoDataPoint(ts, int64(val), MapAttributeDirection[attributes[A.Direction]]) case "iis.request.count": - mb.RecordIisRequestCountDataPoint(ts, int64(val), attributes[A.Request]) + mb.RecordIisRequestCountDataPoint(ts, int64(val), MapAttributeRequest[attributes[A.Request]]) case "iis.request.queue.age.max": mb.RecordIisRequestQueueAgeMaxDataPoint(ts, int64(val)) case "iis.request.queue.count": diff --git a/receiver/memcachedreceiver/internal/metadata/generated_metrics_v2.go b/receiver/memcachedreceiver/internal/metadata/generated_metrics_v2.go index 529d8842fde2..4dee36f467e8 100644 --- a/receiver/memcachedreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/memcachedreceiver/internal/metadata/generated_metrics_v2.go @@ -67,6 +67,148 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeCommand specifies the a value command attribute. +type AttributeCommand int + +const ( + _ AttributeCommand = iota + AttributeCommandGet + AttributeCommandSet + AttributeCommandFlush + AttributeCommandTouch +) + +// String returns the string representation of the AttributeCommand. +func (av AttributeCommand) String() string { + switch av { + case AttributeCommandGet: + return "get" + case AttributeCommandSet: + return "set" + case AttributeCommandFlush: + return "flush" + case AttributeCommandTouch: + return "touch" + } + return "" +} + +// MapAttributeCommand is a helper map of string to AttributeCommand attribute value. +var MapAttributeCommand = map[string]AttributeCommand{ + "get": AttributeCommandGet, + "set": AttributeCommandSet, + "flush": AttributeCommandFlush, + "touch": AttributeCommandTouch, +} + +// AttributeDirection specifies the a value direction attribute. +type AttributeDirection int + +const ( + _ AttributeDirection = iota + AttributeDirectionSent + AttributeDirectionReceived +) + +// String returns the string representation of the AttributeDirection. +func (av AttributeDirection) String() string { + switch av { + case AttributeDirectionSent: + return "sent" + case AttributeDirectionReceived: + return "received" + } + return "" +} + +// MapAttributeDirection is a helper map of string to AttributeDirection attribute value. +var MapAttributeDirection = map[string]AttributeDirection{ + "sent": AttributeDirectionSent, + "received": AttributeDirectionReceived, +} + +// AttributeOperation specifies the a value operation attribute. +type AttributeOperation int + +const ( + _ AttributeOperation = iota + AttributeOperationIncrement + AttributeOperationDecrement + AttributeOperationGet +) + +// String returns the string representation of the AttributeOperation. +func (av AttributeOperation) String() string { + switch av { + case AttributeOperationIncrement: + return "increment" + case AttributeOperationDecrement: + return "decrement" + case AttributeOperationGet: + return "get" + } + return "" +} + +// MapAttributeOperation is a helper map of string to AttributeOperation attribute value. +var MapAttributeOperation = map[string]AttributeOperation{ + "increment": AttributeOperationIncrement, + "decrement": AttributeOperationDecrement, + "get": AttributeOperationGet, +} + +// AttributeState specifies the a value state attribute. +type AttributeState int + +const ( + _ AttributeState = iota + AttributeStateSystem + AttributeStateUser +) + +// String returns the string representation of the AttributeState. +func (av AttributeState) String() string { + switch av { + case AttributeStateSystem: + return "system" + case AttributeStateUser: + return "user" + } + return "" +} + +// MapAttributeState is a helper map of string to AttributeState attribute value. +var MapAttributeState = map[string]AttributeState{ + "system": AttributeStateSystem, + "user": AttributeStateUser, +} + +// AttributeType specifies the a value type attribute. +type AttributeType int + +const ( + _ AttributeType = iota + AttributeTypeHit + AttributeTypeMiss +) + +// String returns the string representation of the AttributeType. +func (av AttributeType) String() string { + switch av { + case AttributeTypeHit: + return "hit" + case AttributeTypeMiss: + return "miss" + } + return "" +} + +// MapAttributeType is a helper map of string to AttributeType attribute value. +var MapAttributeType = map[string]AttributeType{ + "hit": AttributeTypeHit, + "miss": AttributeTypeMiss, +} + type metricMemcachedBytes struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -746,8 +888,8 @@ func (mb *MetricsBuilder) RecordMemcachedBytesDataPoint(ts pcommon.Timestamp, va } // RecordMemcachedCommandsDataPoint adds a data point to memcached.commands metric. -func (mb *MetricsBuilder) RecordMemcachedCommandsDataPoint(ts pcommon.Timestamp, val int64, commandAttributeValue string) { - mb.metricMemcachedCommands.recordDataPoint(mb.startTime, ts, val, commandAttributeValue) +func (mb *MetricsBuilder) RecordMemcachedCommandsDataPoint(ts pcommon.Timestamp, val int64, commandAttributeValue AttributeCommand) { + mb.metricMemcachedCommands.recordDataPoint(mb.startTime, ts, val, commandAttributeValue.String()) } // RecordMemcachedConnectionsCurrentDataPoint adds a data point to memcached.connections.current metric. @@ -761,8 +903,8 @@ func (mb *MetricsBuilder) RecordMemcachedConnectionsTotalDataPoint(ts pcommon.Ti } // RecordMemcachedCPUUsageDataPoint adds a data point to memcached.cpu.usage metric. -func (mb *MetricsBuilder) RecordMemcachedCPUUsageDataPoint(ts pcommon.Timestamp, val float64, stateAttributeValue string) { - mb.metricMemcachedCPUUsage.recordDataPoint(mb.startTime, ts, val, stateAttributeValue) +func (mb *MetricsBuilder) RecordMemcachedCPUUsageDataPoint(ts pcommon.Timestamp, val float64, stateAttributeValue AttributeState) { + mb.metricMemcachedCPUUsage.recordDataPoint(mb.startTime, ts, val, stateAttributeValue.String()) } // RecordMemcachedCurrentItemsDataPoint adds a data point to memcached.current_items metric. @@ -776,18 +918,18 @@ func (mb *MetricsBuilder) RecordMemcachedEvictionsDataPoint(ts pcommon.Timestamp } // RecordMemcachedNetworkDataPoint adds a data point to memcached.network metric. -func (mb *MetricsBuilder) RecordMemcachedNetworkDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue string) { - mb.metricMemcachedNetwork.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordMemcachedNetworkDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue AttributeDirection) { + mb.metricMemcachedNetwork.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordMemcachedOperationHitRatioDataPoint adds a data point to memcached.operation_hit_ratio metric. -func (mb *MetricsBuilder) RecordMemcachedOperationHitRatioDataPoint(ts pcommon.Timestamp, val float64, operationAttributeValue string) { - mb.metricMemcachedOperationHitRatio.recordDataPoint(mb.startTime, ts, val, operationAttributeValue) +func (mb *MetricsBuilder) RecordMemcachedOperationHitRatioDataPoint(ts pcommon.Timestamp, val float64, operationAttributeValue AttributeOperation) { + mb.metricMemcachedOperationHitRatio.recordDataPoint(mb.startTime, ts, val, operationAttributeValue.String()) } // RecordMemcachedOperationsDataPoint adds a data point to memcached.operations metric. -func (mb *MetricsBuilder) RecordMemcachedOperationsDataPoint(ts pcommon.Timestamp, val int64, typeAttributeValue string, operationAttributeValue string) { - mb.metricMemcachedOperations.recordDataPoint(mb.startTime, ts, val, typeAttributeValue, operationAttributeValue) +func (mb *MetricsBuilder) RecordMemcachedOperationsDataPoint(ts pcommon.Timestamp, val int64, typeAttributeValue AttributeType, operationAttributeValue AttributeOperation) { + mb.metricMemcachedOperations.recordDataPoint(mb.startTime, ts, val, typeAttributeValue.String(), operationAttributeValue.String()) } // RecordMemcachedThreadsDataPoint adds a data point to memcached.threads metric. @@ -826,54 +968,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeCommand are the possible values that the attribute "command" can have. -var AttributeCommand = struct { - Get string - Set string - Flush string - Touch string -}{ - "get", - "set", - "flush", - "touch", -} - -// AttributeDirection are the possible values that the attribute "direction" can have. -var AttributeDirection = struct { - Sent string - Received string -}{ - "sent", - "received", -} - -// AttributeOperation are the possible values that the attribute "operation" can have. -var AttributeOperation = struct { - Increment string - Decrement string - Get string -}{ - "increment", - "decrement", - "get", -} - -// AttributeState are the possible values that the attribute "state" can have. -var AttributeState = struct { - System string - User string -}{ - "system", - "user", -} - -// AttributeType are the possible values that the attribute "type" can have. -var AttributeType = struct { - Hit string - Miss string -}{ - "hit", - "miss", -} diff --git a/receiver/memcachedreceiver/scraper.go b/receiver/memcachedreceiver/scraper.go index d3a1f9a2bba8..efafbf68fd63 100644 --- a/receiver/memcachedreceiver/scraper.go +++ b/receiver/memcachedreceiver/scraper.go @@ -79,19 +79,19 @@ func (r *memcachedScraper) scrape(_ context.Context) (pmetric.Metrics, error) { } case "cmd_get": if parsedV, ok := r.parseInt(k, v); ok { - r.mb.RecordMemcachedCommandsDataPoint(now, parsedV, "get") + r.mb.RecordMemcachedCommandsDataPoint(now, parsedV, metadata.AttributeCommandGet) } case "cmd_set": if parsedV, ok := r.parseInt(k, v); ok { - r.mb.RecordMemcachedCommandsDataPoint(now, parsedV, "set") + r.mb.RecordMemcachedCommandsDataPoint(now, parsedV, metadata.AttributeCommandSet) } case "cmd_flush": if parsedV, ok := r.parseInt(k, v); ok { - r.mb.RecordMemcachedCommandsDataPoint(now, parsedV, "flush") + r.mb.RecordMemcachedCommandsDataPoint(now, parsedV, metadata.AttributeCommandFlush) } case "cmd_touch": if parsedV, ok := r.parseInt(k, v); ok { - r.mb.RecordMemcachedCommandsDataPoint(now, parsedV, "touch") + r.mb.RecordMemcachedCommandsDataPoint(now, parsedV, metadata.AttributeCommandTouch) } case "curr_items": if parsedV, ok := r.parseInt(k, v); ok { @@ -109,44 +109,50 @@ func (r *memcachedScraper) scrape(_ context.Context) (pmetric.Metrics, error) { } case "bytes_read": if parsedV, ok := r.parseInt(k, v); ok { - r.mb.RecordMemcachedNetworkDataPoint(now, parsedV, "received") + r.mb.RecordMemcachedNetworkDataPoint(now, parsedV, metadata.AttributeDirectionReceived) } case "bytes_written": if parsedV, ok := r.parseInt(k, v); ok { - r.mb.RecordMemcachedNetworkDataPoint(now, parsedV, "sent") + r.mb.RecordMemcachedNetworkDataPoint(now, parsedV, metadata.AttributeDirectionSent) } case "get_hits": if parsedV, ok := r.parseInt(k, v); ok { - r.mb.RecordMemcachedOperationsDataPoint(now, parsedV, "hit", "get") + r.mb.RecordMemcachedOperationsDataPoint(now, parsedV, metadata.AttributeTypeHit, + metadata.AttributeOperationGet) } case "get_misses": if parsedV, ok := r.parseInt(k, v); ok { - r.mb.RecordMemcachedOperationsDataPoint(now, parsedV, "miss", "get") + r.mb.RecordMemcachedOperationsDataPoint(now, parsedV, metadata.AttributeTypeMiss, + metadata.AttributeOperationGet) } case "incr_hits": if parsedV, ok := r.parseInt(k, v); ok { - r.mb.RecordMemcachedOperationsDataPoint(now, parsedV, "hit", "increment") + r.mb.RecordMemcachedOperationsDataPoint(now, parsedV, metadata.AttributeTypeHit, + metadata.AttributeOperationIncrement) } case "incr_misses": if parsedV, ok := r.parseInt(k, v); ok { - r.mb.RecordMemcachedOperationsDataPoint(now, parsedV, "miss", "increment") + r.mb.RecordMemcachedOperationsDataPoint(now, parsedV, metadata.AttributeTypeMiss, + metadata.AttributeOperationIncrement) } case "decr_hits": if parsedV, ok := r.parseInt(k, v); ok { - r.mb.RecordMemcachedOperationsDataPoint(now, parsedV, "hit", "decrement") + r.mb.RecordMemcachedOperationsDataPoint(now, parsedV, metadata.AttributeTypeHit, + metadata.AttributeOperationDecrement) } case "decr_misses": if parsedV, ok := r.parseInt(k, v); ok { - r.mb.RecordMemcachedOperationsDataPoint(now, parsedV, "miss", "decrement") + r.mb.RecordMemcachedOperationsDataPoint(now, parsedV, metadata.AttributeTypeMiss, + metadata.AttributeOperationDecrement) } case "rusage_system": if parsedV, ok := r.parseFloat(k, v); ok { - r.mb.RecordMemcachedCPUUsageDataPoint(now, parsedV, "system") + r.mb.RecordMemcachedCPUUsageDataPoint(now, parsedV, metadata.AttributeStateSystem) } case "rusage_user": if parsedV, ok := r.parseFloat(k, v); ok { - r.mb.RecordMemcachedCPUUsageDataPoint(now, parsedV, "user") + r.mb.RecordMemcachedCPUUsageDataPoint(now, parsedV, metadata.AttributeStateUser) } } } @@ -157,7 +163,8 @@ func (r *memcachedScraper) scrape(_ context.Context) (pmetric.Metrics, error) { parsedHit, okHit := r.parseInt("incr_hits", stats.Stats["incr_hits"]) parsedMiss, okMiss := r.parseInt("incr_misses", stats.Stats["incr_misses"]) if okHit && okMiss { - r.mb.RecordMemcachedOperationHitRatioDataPoint(now, calculateHitRatio(parsedHit, parsedMiss), "increment") + r.mb.RecordMemcachedOperationHitRatioDataPoint(now, calculateHitRatio(parsedHit, parsedMiss), + metadata.AttributeOperationIncrement) } attributes = pcommon.NewMap() @@ -165,7 +172,8 @@ func (r *memcachedScraper) scrape(_ context.Context) (pmetric.Metrics, error) { parsedHit, okHit = r.parseInt("decr_hits", stats.Stats["decr_hits"]) parsedMiss, okMiss = r.parseInt("decr_misses", stats.Stats["decr_misses"]) if okHit && okMiss { - r.mb.RecordMemcachedOperationHitRatioDataPoint(now, calculateHitRatio(parsedHit, parsedMiss), "decrement") + r.mb.RecordMemcachedOperationHitRatioDataPoint(now, calculateHitRatio(parsedHit, parsedMiss), + metadata.AttributeOperationDecrement) } attributes = pcommon.NewMap() @@ -173,7 +181,7 @@ func (r *memcachedScraper) scrape(_ context.Context) (pmetric.Metrics, error) { parsedHit, okHit = r.parseInt("get_hits", stats.Stats["get_hits"]) parsedMiss, okMiss = r.parseInt("get_misses", stats.Stats["get_misses"]) if okHit && okMiss { - r.mb.RecordMemcachedOperationHitRatioDataPoint(now, calculateHitRatio(parsedHit, parsedMiss), "get") + r.mb.RecordMemcachedOperationHitRatioDataPoint(now, calculateHitRatio(parsedHit, parsedMiss), metadata.AttributeOperationGet) } } diff --git a/receiver/mongodbatlasreceiver/documentation.md b/receiver/mongodbatlasreceiver/documentation.md index bfb41f87ff2a..f75090df95c5 100644 --- a/receiver/mongodbatlasreceiver/documentation.md +++ b/receiver/mongodbatlasreceiver/documentation.md @@ -69,8 +69,8 @@ These are the metrics available for this scraper. | **mongodbatlas.system.network.io.max** | System Network IO Aggregate of MongoDB Metrics MAX_SYSTEM_NETWORK_OUT, MAX_SYSTEM_NETWORK_IN | By/s | Gauge(Double) | | | **mongodbatlas.system.paging.io.average** | Swap IO Aggregate of MongoDB Metrics SWAP_IO_IN, SWAP_IO_OUT | {pages}/s | Gauge(Double) | | | **mongodbatlas.system.paging.io.max** | Swap IO Aggregate of MongoDB Metrics MAX_SWAP_IO_IN, MAX_SWAP_IO_OUT | {pages}/s | Gauge(Double) | | -| **mongodbatlas.system.paging.usage.average** | Swap usage Aggregate of MongoDB Metrics SWAP_USAGE_FREE, SWAP_USAGE_USED | KiBy | Gauge(Double) | | -| **mongodbatlas.system.paging.usage.max** | Swap usage Aggregate of MongoDB Metrics MAX_SWAP_USAGE_FREE, MAX_SWAP_USAGE_USED | KiBy | Gauge(Double) | | +| **mongodbatlas.system.paging.usage.average** | Swap usage Aggregate of MongoDB Metrics SWAP_USAGE_FREE, SWAP_USAGE_USED | KiBy | Gauge(Double) | | +| **mongodbatlas.system.paging.usage.max** | Swap usage Aggregate of MongoDB Metrics MAX_SWAP_USAGE_FREE, MAX_SWAP_USAGE_USED | KiBy | Gauge(Double) | | **Highlighted metrics** are emitted by default. Other metrics are optional and not emitted by default. Any metric can be enabled or disabled with the following scraper configuration: diff --git a/receiver/mongodbatlasreceiver/internal/metadata/generated_metrics_v2.go b/receiver/mongodbatlasreceiver/internal/metadata/generated_metrics_v2.go index 1427367b84db..1bd6af58ad7d 100644 --- a/receiver/mongodbatlasreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/mongodbatlasreceiver/internal/metadata/generated_metrics_v2.go @@ -275,6 +275,726 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeAssertType specifies the a value assert_type attribute. +type AttributeAssertType int + +const ( + _ AttributeAssertType = iota + AttributeAssertTypeRegular + AttributeAssertTypeWarning + AttributeAssertTypeMsg + AttributeAssertTypeUser +) + +// String returns the string representation of the AttributeAssertType. +func (av AttributeAssertType) String() string { + switch av { + case AttributeAssertTypeRegular: + return "regular" + case AttributeAssertTypeWarning: + return "warning" + case AttributeAssertTypeMsg: + return "msg" + case AttributeAssertTypeUser: + return "user" + } + return "" +} + +// MapAttributeAssertType is a helper map of string to AttributeAssertType attribute value. +var MapAttributeAssertType = map[string]AttributeAssertType{ + "regular": AttributeAssertTypeRegular, + "warning": AttributeAssertTypeWarning, + "msg": AttributeAssertTypeMsg, + "user": AttributeAssertTypeUser, +} + +// AttributeBtreeCounterType specifies the a value btree_counter_type attribute. +type AttributeBtreeCounterType int + +const ( + _ AttributeBtreeCounterType = iota + AttributeBtreeCounterTypeAccesses + AttributeBtreeCounterTypeHits + AttributeBtreeCounterTypeMisses +) + +// String returns the string representation of the AttributeBtreeCounterType. +func (av AttributeBtreeCounterType) String() string { + switch av { + case AttributeBtreeCounterTypeAccesses: + return "accesses" + case AttributeBtreeCounterTypeHits: + return "hits" + case AttributeBtreeCounterTypeMisses: + return "misses" + } + return "" +} + +// MapAttributeBtreeCounterType is a helper map of string to AttributeBtreeCounterType attribute value. +var MapAttributeBtreeCounterType = map[string]AttributeBtreeCounterType{ + "accesses": AttributeBtreeCounterTypeAccesses, + "hits": AttributeBtreeCounterTypeHits, + "misses": AttributeBtreeCounterTypeMisses, +} + +// AttributeCacheDirection specifies the a value cache_direction attribute. +type AttributeCacheDirection int + +const ( + _ AttributeCacheDirection = iota + AttributeCacheDirectionReadInto + AttributeCacheDirectionWrittenFrom +) + +// String returns the string representation of the AttributeCacheDirection. +func (av AttributeCacheDirection) String() string { + switch av { + case AttributeCacheDirectionReadInto: + return "read_into" + case AttributeCacheDirectionWrittenFrom: + return "written_from" + } + return "" +} + +// MapAttributeCacheDirection is a helper map of string to AttributeCacheDirection attribute value. +var MapAttributeCacheDirection = map[string]AttributeCacheDirection{ + "read_into": AttributeCacheDirectionReadInto, + "written_from": AttributeCacheDirectionWrittenFrom, +} + +// AttributeCacheStatus specifies the a value cache_status attribute. +type AttributeCacheStatus int + +const ( + _ AttributeCacheStatus = iota + AttributeCacheStatusDirty + AttributeCacheStatusUsed +) + +// String returns the string representation of the AttributeCacheStatus. +func (av AttributeCacheStatus) String() string { + switch av { + case AttributeCacheStatusDirty: + return "dirty" + case AttributeCacheStatusUsed: + return "used" + } + return "" +} + +// MapAttributeCacheStatus is a helper map of string to AttributeCacheStatus attribute value. +var MapAttributeCacheStatus = map[string]AttributeCacheStatus{ + "dirty": AttributeCacheStatusDirty, + "used": AttributeCacheStatusUsed, +} + +// AttributeClusterRole specifies the a value cluster_role attribute. +type AttributeClusterRole int + +const ( + _ AttributeClusterRole = iota + AttributeClusterRolePrimary + AttributeClusterRoleReplica +) + +// String returns the string representation of the AttributeClusterRole. +func (av AttributeClusterRole) String() string { + switch av { + case AttributeClusterRolePrimary: + return "primary" + case AttributeClusterRoleReplica: + return "replica" + } + return "" +} + +// MapAttributeClusterRole is a helper map of string to AttributeClusterRole attribute value. +var MapAttributeClusterRole = map[string]AttributeClusterRole{ + "primary": AttributeClusterRolePrimary, + "replica": AttributeClusterRoleReplica, +} + +// AttributeCPUState specifies the a value cpu_state attribute. +type AttributeCPUState int + +const ( + _ AttributeCPUState = iota + AttributeCPUStateKernel + AttributeCPUStateUser + AttributeCPUStateNice + AttributeCPUStateIowait + AttributeCPUStateIrq + AttributeCPUStateSoftirq + AttributeCPUStateGuest + AttributeCPUStateSteal +) + +// String returns the string representation of the AttributeCPUState. +func (av AttributeCPUState) String() string { + switch av { + case AttributeCPUStateKernel: + return "kernel" + case AttributeCPUStateUser: + return "user" + case AttributeCPUStateNice: + return "nice" + case AttributeCPUStateIowait: + return "iowait" + case AttributeCPUStateIrq: + return "irq" + case AttributeCPUStateSoftirq: + return "softirq" + case AttributeCPUStateGuest: + return "guest" + case AttributeCPUStateSteal: + return "steal" + } + return "" +} + +// MapAttributeCPUState is a helper map of string to AttributeCPUState attribute value. +var MapAttributeCPUState = map[string]AttributeCPUState{ + "kernel": AttributeCPUStateKernel, + "user": AttributeCPUStateUser, + "nice": AttributeCPUStateNice, + "iowait": AttributeCPUStateIowait, + "irq": AttributeCPUStateIrq, + "softirq": AttributeCPUStateSoftirq, + "guest": AttributeCPUStateGuest, + "steal": AttributeCPUStateSteal, +} + +// AttributeCursorState specifies the a value cursor_state attribute. +type AttributeCursorState int + +const ( + _ AttributeCursorState = iota + AttributeCursorStateTimedOut + AttributeCursorStateOpen +) + +// String returns the string representation of the AttributeCursorState. +func (av AttributeCursorState) String() string { + switch av { + case AttributeCursorStateTimedOut: + return "timed_out" + case AttributeCursorStateOpen: + return "open" + } + return "" +} + +// MapAttributeCursorState is a helper map of string to AttributeCursorState attribute value. +var MapAttributeCursorState = map[string]AttributeCursorState{ + "timed_out": AttributeCursorStateTimedOut, + "open": AttributeCursorStateOpen, +} + +// AttributeDirection specifies the a value direction attribute. +type AttributeDirection int + +const ( + _ AttributeDirection = iota + AttributeDirectionReceive + AttributeDirectionTransmit +) + +// String returns the string representation of the AttributeDirection. +func (av AttributeDirection) String() string { + switch av { + case AttributeDirectionReceive: + return "receive" + case AttributeDirectionTransmit: + return "transmit" + } + return "" +} + +// MapAttributeDirection is a helper map of string to AttributeDirection attribute value. +var MapAttributeDirection = map[string]AttributeDirection{ + "receive": AttributeDirectionReceive, + "transmit": AttributeDirectionTransmit, +} + +// AttributeDiskDirection specifies the a value disk_direction attribute. +type AttributeDiskDirection int + +const ( + _ AttributeDiskDirection = iota + AttributeDiskDirectionRead + AttributeDiskDirectionWrite + AttributeDiskDirectionTotal +) + +// String returns the string representation of the AttributeDiskDirection. +func (av AttributeDiskDirection) String() string { + switch av { + case AttributeDiskDirectionRead: + return "read" + case AttributeDiskDirectionWrite: + return "write" + case AttributeDiskDirectionTotal: + return "total" + } + return "" +} + +// MapAttributeDiskDirection is a helper map of string to AttributeDiskDirection attribute value. +var MapAttributeDiskDirection = map[string]AttributeDiskDirection{ + "read": AttributeDiskDirectionRead, + "write": AttributeDiskDirectionWrite, + "total": AttributeDiskDirectionTotal, +} + +// AttributeDiskStatus specifies the a value disk_status attribute. +type AttributeDiskStatus int + +const ( + _ AttributeDiskStatus = iota + AttributeDiskStatusFree + AttributeDiskStatusUsed +) + +// String returns the string representation of the AttributeDiskStatus. +func (av AttributeDiskStatus) String() string { + switch av { + case AttributeDiskStatusFree: + return "free" + case AttributeDiskStatusUsed: + return "used" + } + return "" +} + +// MapAttributeDiskStatus is a helper map of string to AttributeDiskStatus attribute value. +var MapAttributeDiskStatus = map[string]AttributeDiskStatus{ + "free": AttributeDiskStatusFree, + "used": AttributeDiskStatusUsed, +} + +// AttributeDocumentStatus specifies the a value document_status attribute. +type AttributeDocumentStatus int + +const ( + _ AttributeDocumentStatus = iota + AttributeDocumentStatusReturned + AttributeDocumentStatusInserted + AttributeDocumentStatusUpdated + AttributeDocumentStatusDeleted +) + +// String returns the string representation of the AttributeDocumentStatus. +func (av AttributeDocumentStatus) String() string { + switch av { + case AttributeDocumentStatusReturned: + return "returned" + case AttributeDocumentStatusInserted: + return "inserted" + case AttributeDocumentStatusUpdated: + return "updated" + case AttributeDocumentStatusDeleted: + return "deleted" + } + return "" +} + +// MapAttributeDocumentStatus is a helper map of string to AttributeDocumentStatus attribute value. +var MapAttributeDocumentStatus = map[string]AttributeDocumentStatus{ + "returned": AttributeDocumentStatusReturned, + "inserted": AttributeDocumentStatusInserted, + "updated": AttributeDocumentStatusUpdated, + "deleted": AttributeDocumentStatusDeleted, +} + +// AttributeExecutionType specifies the a value execution_type attribute. +type AttributeExecutionType int + +const ( + _ AttributeExecutionType = iota + AttributeExecutionTypeReads + AttributeExecutionTypeWrites + AttributeExecutionTypeCommands +) + +// String returns the string representation of the AttributeExecutionType. +func (av AttributeExecutionType) String() string { + switch av { + case AttributeExecutionTypeReads: + return "reads" + case AttributeExecutionTypeWrites: + return "writes" + case AttributeExecutionTypeCommands: + return "commands" + } + return "" +} + +// MapAttributeExecutionType is a helper map of string to AttributeExecutionType attribute value. +var MapAttributeExecutionType = map[string]AttributeExecutionType{ + "reads": AttributeExecutionTypeReads, + "writes": AttributeExecutionTypeWrites, + "commands": AttributeExecutionTypeCommands, +} + +// AttributeGlobalLockState specifies the a value global_lock_state attribute. +type AttributeGlobalLockState int + +const ( + _ AttributeGlobalLockState = iota + AttributeGlobalLockStateCurrentQueueTotal + AttributeGlobalLockStateCurrentQueueReaders + AttributeGlobalLockStateCurrentQueueWriters +) + +// String returns the string representation of the AttributeGlobalLockState. +func (av AttributeGlobalLockState) String() string { + switch av { + case AttributeGlobalLockStateCurrentQueueTotal: + return "current_queue_total" + case AttributeGlobalLockStateCurrentQueueReaders: + return "current_queue_readers" + case AttributeGlobalLockStateCurrentQueueWriters: + return "current_queue_writers" + } + return "" +} + +// MapAttributeGlobalLockState is a helper map of string to AttributeGlobalLockState attribute value. +var MapAttributeGlobalLockState = map[string]AttributeGlobalLockState{ + "current_queue_total": AttributeGlobalLockStateCurrentQueueTotal, + "current_queue_readers": AttributeGlobalLockStateCurrentQueueReaders, + "current_queue_writers": AttributeGlobalLockStateCurrentQueueWriters, +} + +// AttributeMemoryIssueType specifies the a value memory_issue_type attribute. +type AttributeMemoryIssueType int + +const ( + _ AttributeMemoryIssueType = iota + AttributeMemoryIssueTypeExtraInfo + AttributeMemoryIssueTypeGlobalAccessesNotInMemory + AttributeMemoryIssueTypeExceptionsThrown +) + +// String returns the string representation of the AttributeMemoryIssueType. +func (av AttributeMemoryIssueType) String() string { + switch av { + case AttributeMemoryIssueTypeExtraInfo: + return "extra_info" + case AttributeMemoryIssueTypeGlobalAccessesNotInMemory: + return "global_accesses_not_in_memory" + case AttributeMemoryIssueTypeExceptionsThrown: + return "exceptions_thrown" + } + return "" +} + +// MapAttributeMemoryIssueType is a helper map of string to AttributeMemoryIssueType attribute value. +var MapAttributeMemoryIssueType = map[string]AttributeMemoryIssueType{ + "extra_info": AttributeMemoryIssueTypeExtraInfo, + "global_accesses_not_in_memory": AttributeMemoryIssueTypeGlobalAccessesNotInMemory, + "exceptions_thrown": AttributeMemoryIssueTypeExceptionsThrown, +} + +// AttributeMemoryState specifies the a value memory_state attribute. +type AttributeMemoryState int + +const ( + _ AttributeMemoryState = iota + AttributeMemoryStateResident + AttributeMemoryStateVirtual + AttributeMemoryStateMapped + AttributeMemoryStateComputed + AttributeMemoryStateShared + AttributeMemoryStateFree + AttributeMemoryStateUsed +) + +// String returns the string representation of the AttributeMemoryState. +func (av AttributeMemoryState) String() string { + switch av { + case AttributeMemoryStateResident: + return "resident" + case AttributeMemoryStateVirtual: + return "virtual" + case AttributeMemoryStateMapped: + return "mapped" + case AttributeMemoryStateComputed: + return "computed" + case AttributeMemoryStateShared: + return "shared" + case AttributeMemoryStateFree: + return "free" + case AttributeMemoryStateUsed: + return "used" + } + return "" +} + +// MapAttributeMemoryState is a helper map of string to AttributeMemoryState attribute value. +var MapAttributeMemoryState = map[string]AttributeMemoryState{ + "resident": AttributeMemoryStateResident, + "virtual": AttributeMemoryStateVirtual, + "mapped": AttributeMemoryStateMapped, + "computed": AttributeMemoryStateComputed, + "shared": AttributeMemoryStateShared, + "free": AttributeMemoryStateFree, + "used": AttributeMemoryStateUsed, +} + +// AttributeMemoryStatus specifies the a value memory_status attribute. +type AttributeMemoryStatus int + +const ( + _ AttributeMemoryStatus = iota + AttributeMemoryStatusAvailable + AttributeMemoryStatusBuffers + AttributeMemoryStatusCached + AttributeMemoryStatusFree + AttributeMemoryStatusShared + AttributeMemoryStatusUsed +) + +// String returns the string representation of the AttributeMemoryStatus. +func (av AttributeMemoryStatus) String() string { + switch av { + case AttributeMemoryStatusAvailable: + return "available" + case AttributeMemoryStatusBuffers: + return "buffers" + case AttributeMemoryStatusCached: + return "cached" + case AttributeMemoryStatusFree: + return "free" + case AttributeMemoryStatusShared: + return "shared" + case AttributeMemoryStatusUsed: + return "used" + } + return "" +} + +// MapAttributeMemoryStatus is a helper map of string to AttributeMemoryStatus attribute value. +var MapAttributeMemoryStatus = map[string]AttributeMemoryStatus{ + "available": AttributeMemoryStatusAvailable, + "buffers": AttributeMemoryStatusBuffers, + "cached": AttributeMemoryStatusCached, + "free": AttributeMemoryStatusFree, + "shared": AttributeMemoryStatusShared, + "used": AttributeMemoryStatusUsed, +} + +// AttributeObjectType specifies the a value object_type attribute. +type AttributeObjectType int + +const ( + _ AttributeObjectType = iota + AttributeObjectTypeCollection + AttributeObjectTypeIndex + AttributeObjectTypeExtent + AttributeObjectTypeObject + AttributeObjectTypeView + AttributeObjectTypeStorage + AttributeObjectTypeData +) + +// String returns the string representation of the AttributeObjectType. +func (av AttributeObjectType) String() string { + switch av { + case AttributeObjectTypeCollection: + return "collection" + case AttributeObjectTypeIndex: + return "index" + case AttributeObjectTypeExtent: + return "extent" + case AttributeObjectTypeObject: + return "object" + case AttributeObjectTypeView: + return "view" + case AttributeObjectTypeStorage: + return "storage" + case AttributeObjectTypeData: + return "data" + } + return "" +} + +// MapAttributeObjectType is a helper map of string to AttributeObjectType attribute value. +var MapAttributeObjectType = map[string]AttributeObjectType{ + "collection": AttributeObjectTypeCollection, + "index": AttributeObjectTypeIndex, + "extent": AttributeObjectTypeExtent, + "object": AttributeObjectTypeObject, + "view": AttributeObjectTypeView, + "storage": AttributeObjectTypeStorage, + "data": AttributeObjectTypeData, +} + +// AttributeOperation specifies the a value operation attribute. +type AttributeOperation int + +const ( + _ AttributeOperation = iota + AttributeOperationCmd + AttributeOperationQuery + AttributeOperationUpdate + AttributeOperationDelete + AttributeOperationGetmore + AttributeOperationInsert + AttributeOperationScanAndOrder +) + +// String returns the string representation of the AttributeOperation. +func (av AttributeOperation) String() string { + switch av { + case AttributeOperationCmd: + return "cmd" + case AttributeOperationQuery: + return "query" + case AttributeOperationUpdate: + return "update" + case AttributeOperationDelete: + return "delete" + case AttributeOperationGetmore: + return "getmore" + case AttributeOperationInsert: + return "insert" + case AttributeOperationScanAndOrder: + return "scan_and_order" + } + return "" +} + +// MapAttributeOperation is a helper map of string to AttributeOperation attribute value. +var MapAttributeOperation = map[string]AttributeOperation{ + "cmd": AttributeOperationCmd, + "query": AttributeOperationQuery, + "update": AttributeOperationUpdate, + "delete": AttributeOperationDelete, + "getmore": AttributeOperationGetmore, + "insert": AttributeOperationInsert, + "scan_and_order": AttributeOperationScanAndOrder, +} + +// AttributeOplogType specifies the a value oplog_type attribute. +type AttributeOplogType int + +const ( + _ AttributeOplogType = iota + AttributeOplogTypeSlaveLagMasterTime + AttributeOplogTypeMasterTime + AttributeOplogTypeMasterLagTimeDiff +) + +// String returns the string representation of the AttributeOplogType. +func (av AttributeOplogType) String() string { + switch av { + case AttributeOplogTypeSlaveLagMasterTime: + return "slave_lag_master_time" + case AttributeOplogTypeMasterTime: + return "master_time" + case AttributeOplogTypeMasterLagTimeDiff: + return "master_lag_time_diff" + } + return "" +} + +// MapAttributeOplogType is a helper map of string to AttributeOplogType attribute value. +var MapAttributeOplogType = map[string]AttributeOplogType{ + "slave_lag_master_time": AttributeOplogTypeSlaveLagMasterTime, + "master_time": AttributeOplogTypeMasterTime, + "master_lag_time_diff": AttributeOplogTypeMasterLagTimeDiff, +} + +// AttributeScannedType specifies the a value scanned_type attribute. +type AttributeScannedType int + +const ( + _ AttributeScannedType = iota + AttributeScannedTypeIndexItems + AttributeScannedTypeObjects +) + +// String returns the string representation of the AttributeScannedType. +func (av AttributeScannedType) String() string { + switch av { + case AttributeScannedTypeIndexItems: + return "index_items" + case AttributeScannedTypeObjects: + return "objects" + } + return "" +} + +// MapAttributeScannedType is a helper map of string to AttributeScannedType attribute value. +var MapAttributeScannedType = map[string]AttributeScannedType{ + "index_items": AttributeScannedTypeIndexItems, + "objects": AttributeScannedTypeObjects, +} + +// AttributeStorageStatus specifies the a value storage_status attribute. +type AttributeStorageStatus int + +const ( + _ AttributeStorageStatus = iota + AttributeStorageStatusTotal + AttributeStorageStatusDataSize + AttributeStorageStatusIndexSize + AttributeStorageStatusDataSizeWoSystem +) + +// String returns the string representation of the AttributeStorageStatus. +func (av AttributeStorageStatus) String() string { + switch av { + case AttributeStorageStatusTotal: + return "total" + case AttributeStorageStatusDataSize: + return "data_size" + case AttributeStorageStatusIndexSize: + return "index_size" + case AttributeStorageStatusDataSizeWoSystem: + return "data_size_wo_system" + } + return "" +} + +// MapAttributeStorageStatus is a helper map of string to AttributeStorageStatus attribute value. +var MapAttributeStorageStatus = map[string]AttributeStorageStatus{ + "total": AttributeStorageStatusTotal, + "data_size": AttributeStorageStatusDataSize, + "index_size": AttributeStorageStatusIndexSize, + "data_size_wo_system": AttributeStorageStatusDataSizeWoSystem, +} + +// AttributeTicketType specifies the a value ticket_type attribute. +type AttributeTicketType int + +const ( + _ AttributeTicketType = iota + AttributeTicketTypeAvailableReads + AttributeTicketTypeAvailableWrites +) + +// String returns the string representation of the AttributeTicketType. +func (av AttributeTicketType) String() string { + switch av { + case AttributeTicketTypeAvailableReads: + return "available_reads" + case AttributeTicketTypeAvailableWrites: + return "available_writes" + } + return "" +} + +// MapAttributeTicketType is a helper map of string to AttributeTicketType attribute value. +var MapAttributeTicketType = map[string]AttributeTicketType{ + "available_reads": AttributeTicketTypeAvailableReads, + "available_writes": AttributeTicketTypeAvailableWrites, +} + type metricMongodbatlasDbCounts struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -3392,7 +4112,7 @@ func (m *metricMongodbatlasSystemPagingUsageAverage) init() { m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) } -func (m *metricMongodbatlasSystemPagingUsageAverage) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, directionAttributeValue string) { +func (m *metricMongodbatlasSystemPagingUsageAverage) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, memoryStateAttributeValue string) { if !m.settings.Enabled { return } @@ -3400,7 +4120,7 @@ func (m *metricMongodbatlasSystemPagingUsageAverage) recordDataPoint(start pcomm dp.SetStartTimestamp(start) dp.SetTimestamp(ts) dp.SetDoubleVal(val) - dp.Attributes().Insert(A.Direction, pcommon.NewValueString(directionAttributeValue)) + dp.Attributes().Insert(A.MemoryState, pcommon.NewValueString(memoryStateAttributeValue)) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. @@ -3443,7 +4163,7 @@ func (m *metricMongodbatlasSystemPagingUsageMax) init() { m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) } -func (m *metricMongodbatlasSystemPagingUsageMax) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, directionAttributeValue string) { +func (m *metricMongodbatlasSystemPagingUsageMax) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, memoryStateAttributeValue string) { if !m.settings.Enabled { return } @@ -3451,7 +4171,7 @@ func (m *metricMongodbatlasSystemPagingUsageMax) recordDataPoint(start pcommon.T dp.SetStartTimestamp(start) dp.SetTimestamp(ts) dp.SetDoubleVal(val) - dp.Attributes().Insert(A.Direction, pcommon.NewValueString(directionAttributeValue)) + dp.Attributes().Insert(A.MemoryState, pcommon.NewValueString(memoryStateAttributeValue)) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. @@ -3804,68 +4524,68 @@ func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pmetric.Metrics { } // RecordMongodbatlasDbCountsDataPoint adds a data point to mongodbatlas.db.counts metric. -func (mb *MetricsBuilder) RecordMongodbatlasDbCountsDataPoint(ts pcommon.Timestamp, val float64, objectTypeAttributeValue string) { - mb.metricMongodbatlasDbCounts.recordDataPoint(mb.startTime, ts, val, objectTypeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasDbCountsDataPoint(ts pcommon.Timestamp, val float64, objectTypeAttributeValue AttributeObjectType) { + mb.metricMongodbatlasDbCounts.recordDataPoint(mb.startTime, ts, val, objectTypeAttributeValue.String()) } // RecordMongodbatlasDbSizeDataPoint adds a data point to mongodbatlas.db.size metric. -func (mb *MetricsBuilder) RecordMongodbatlasDbSizeDataPoint(ts pcommon.Timestamp, val float64, objectTypeAttributeValue string) { - mb.metricMongodbatlasDbSize.recordDataPoint(mb.startTime, ts, val, objectTypeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasDbSizeDataPoint(ts pcommon.Timestamp, val float64, objectTypeAttributeValue AttributeObjectType) { + mb.metricMongodbatlasDbSize.recordDataPoint(mb.startTime, ts, val, objectTypeAttributeValue.String()) } // RecordMongodbatlasDiskPartitionIopsAverageDataPoint adds a data point to mongodbatlas.disk.partition.iops.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionIopsAverageDataPoint(ts pcommon.Timestamp, val float64, diskDirectionAttributeValue string) { - mb.metricMongodbatlasDiskPartitionIopsAverage.recordDataPoint(mb.startTime, ts, val, diskDirectionAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionIopsAverageDataPoint(ts pcommon.Timestamp, val float64, diskDirectionAttributeValue AttributeDiskDirection) { + mb.metricMongodbatlasDiskPartitionIopsAverage.recordDataPoint(mb.startTime, ts, val, diskDirectionAttributeValue.String()) } // RecordMongodbatlasDiskPartitionIopsMaxDataPoint adds a data point to mongodbatlas.disk.partition.iops.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionIopsMaxDataPoint(ts pcommon.Timestamp, val float64, diskDirectionAttributeValue string) { - mb.metricMongodbatlasDiskPartitionIopsMax.recordDataPoint(mb.startTime, ts, val, diskDirectionAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionIopsMaxDataPoint(ts pcommon.Timestamp, val float64, diskDirectionAttributeValue AttributeDiskDirection) { + mb.metricMongodbatlasDiskPartitionIopsMax.recordDataPoint(mb.startTime, ts, val, diskDirectionAttributeValue.String()) } // RecordMongodbatlasDiskPartitionLatencyAverageDataPoint adds a data point to mongodbatlas.disk.partition.latency.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionLatencyAverageDataPoint(ts pcommon.Timestamp, val float64, diskDirectionAttributeValue string) { - mb.metricMongodbatlasDiskPartitionLatencyAverage.recordDataPoint(mb.startTime, ts, val, diskDirectionAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionLatencyAverageDataPoint(ts pcommon.Timestamp, val float64, diskDirectionAttributeValue AttributeDiskDirection) { + mb.metricMongodbatlasDiskPartitionLatencyAverage.recordDataPoint(mb.startTime, ts, val, diskDirectionAttributeValue.String()) } // RecordMongodbatlasDiskPartitionLatencyMaxDataPoint adds a data point to mongodbatlas.disk.partition.latency.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionLatencyMaxDataPoint(ts pcommon.Timestamp, val float64, diskDirectionAttributeValue string) { - mb.metricMongodbatlasDiskPartitionLatencyMax.recordDataPoint(mb.startTime, ts, val, diskDirectionAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionLatencyMaxDataPoint(ts pcommon.Timestamp, val float64, diskDirectionAttributeValue AttributeDiskDirection) { + mb.metricMongodbatlasDiskPartitionLatencyMax.recordDataPoint(mb.startTime, ts, val, diskDirectionAttributeValue.String()) } // RecordMongodbatlasDiskPartitionSpaceAverageDataPoint adds a data point to mongodbatlas.disk.partition.space.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionSpaceAverageDataPoint(ts pcommon.Timestamp, val float64, diskStatusAttributeValue string) { - mb.metricMongodbatlasDiskPartitionSpaceAverage.recordDataPoint(mb.startTime, ts, val, diskStatusAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionSpaceAverageDataPoint(ts pcommon.Timestamp, val float64, diskStatusAttributeValue AttributeDiskStatus) { + mb.metricMongodbatlasDiskPartitionSpaceAverage.recordDataPoint(mb.startTime, ts, val, diskStatusAttributeValue.String()) } // RecordMongodbatlasDiskPartitionSpaceMaxDataPoint adds a data point to mongodbatlas.disk.partition.space.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionSpaceMaxDataPoint(ts pcommon.Timestamp, val float64, diskStatusAttributeValue string) { - mb.metricMongodbatlasDiskPartitionSpaceMax.recordDataPoint(mb.startTime, ts, val, diskStatusAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionSpaceMaxDataPoint(ts pcommon.Timestamp, val float64, diskStatusAttributeValue AttributeDiskStatus) { + mb.metricMongodbatlasDiskPartitionSpaceMax.recordDataPoint(mb.startTime, ts, val, diskStatusAttributeValue.String()) } // RecordMongodbatlasDiskPartitionUsageAverageDataPoint adds a data point to mongodbatlas.disk.partition.usage.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionUsageAverageDataPoint(ts pcommon.Timestamp, val float64, diskStatusAttributeValue string) { - mb.metricMongodbatlasDiskPartitionUsageAverage.recordDataPoint(mb.startTime, ts, val, diskStatusAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionUsageAverageDataPoint(ts pcommon.Timestamp, val float64, diskStatusAttributeValue AttributeDiskStatus) { + mb.metricMongodbatlasDiskPartitionUsageAverage.recordDataPoint(mb.startTime, ts, val, diskStatusAttributeValue.String()) } // RecordMongodbatlasDiskPartitionUsageMaxDataPoint adds a data point to mongodbatlas.disk.partition.usage.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionUsageMaxDataPoint(ts pcommon.Timestamp, val float64, diskStatusAttributeValue string) { - mb.metricMongodbatlasDiskPartitionUsageMax.recordDataPoint(mb.startTime, ts, val, diskStatusAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionUsageMaxDataPoint(ts pcommon.Timestamp, val float64, diskStatusAttributeValue AttributeDiskStatus) { + mb.metricMongodbatlasDiskPartitionUsageMax.recordDataPoint(mb.startTime, ts, val, diskStatusAttributeValue.String()) } // RecordMongodbatlasDiskPartitionUtilizationAverageDataPoint adds a data point to mongodbatlas.disk.partition.utilization.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionUtilizationAverageDataPoint(ts pcommon.Timestamp, val float64, diskStatusAttributeValue string) { - mb.metricMongodbatlasDiskPartitionUtilizationAverage.recordDataPoint(mb.startTime, ts, val, diskStatusAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionUtilizationAverageDataPoint(ts pcommon.Timestamp, val float64, diskStatusAttributeValue AttributeDiskStatus) { + mb.metricMongodbatlasDiskPartitionUtilizationAverage.recordDataPoint(mb.startTime, ts, val, diskStatusAttributeValue.String()) } // RecordMongodbatlasDiskPartitionUtilizationMaxDataPoint adds a data point to mongodbatlas.disk.partition.utilization.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionUtilizationMaxDataPoint(ts pcommon.Timestamp, val float64, diskStatusAttributeValue string) { - mb.metricMongodbatlasDiskPartitionUtilizationMax.recordDataPoint(mb.startTime, ts, val, diskStatusAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasDiskPartitionUtilizationMaxDataPoint(ts pcommon.Timestamp, val float64, diskStatusAttributeValue AttributeDiskStatus) { + mb.metricMongodbatlasDiskPartitionUtilizationMax.recordDataPoint(mb.startTime, ts, val, diskStatusAttributeValue.String()) } // RecordMongodbatlasProcessAssertsDataPoint adds a data point to mongodbatlas.process.asserts metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessAssertsDataPoint(ts pcommon.Timestamp, val float64, assertTypeAttributeValue string) { - mb.metricMongodbatlasProcessAsserts.recordDataPoint(mb.startTime, ts, val, assertTypeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessAssertsDataPoint(ts pcommon.Timestamp, val float64, assertTypeAttributeValue AttributeAssertType) { + mb.metricMongodbatlasProcessAsserts.recordDataPoint(mb.startTime, ts, val, assertTypeAttributeValue.String()) } // RecordMongodbatlasProcessBackgroundFlushDataPoint adds a data point to mongodbatlas.process.background_flush metric. @@ -3874,13 +4594,13 @@ func (mb *MetricsBuilder) RecordMongodbatlasProcessBackgroundFlushDataPoint(ts p } // RecordMongodbatlasProcessCacheIoDataPoint adds a data point to mongodbatlas.process.cache.io metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessCacheIoDataPoint(ts pcommon.Timestamp, val float64, cacheDirectionAttributeValue string) { - mb.metricMongodbatlasProcessCacheIo.recordDataPoint(mb.startTime, ts, val, cacheDirectionAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessCacheIoDataPoint(ts pcommon.Timestamp, val float64, cacheDirectionAttributeValue AttributeCacheDirection) { + mb.metricMongodbatlasProcessCacheIo.recordDataPoint(mb.startTime, ts, val, cacheDirectionAttributeValue.String()) } // RecordMongodbatlasProcessCacheSizeDataPoint adds a data point to mongodbatlas.process.cache.size metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessCacheSizeDataPoint(ts pcommon.Timestamp, val float64, cacheStatusAttributeValue string) { - mb.metricMongodbatlasProcessCacheSize.recordDataPoint(mb.startTime, ts, val, cacheStatusAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessCacheSizeDataPoint(ts pcommon.Timestamp, val float64, cacheStatusAttributeValue AttributeCacheStatus) { + mb.metricMongodbatlasProcessCacheSize.recordDataPoint(mb.startTime, ts, val, cacheStatusAttributeValue.String()) } // RecordMongodbatlasProcessConnectionsDataPoint adds a data point to mongodbatlas.process.connections metric. @@ -3889,88 +4609,88 @@ func (mb *MetricsBuilder) RecordMongodbatlasProcessConnectionsDataPoint(ts pcomm } // RecordMongodbatlasProcessCPUChildrenNormalizedUsageAverageDataPoint adds a data point to mongodbatlas.process.cpu.children.normalized.usage.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUChildrenNormalizedUsageAverageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasProcessCPUChildrenNormalizedUsageAverage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUChildrenNormalizedUsageAverageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasProcessCPUChildrenNormalizedUsageAverage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasProcessCPUChildrenNormalizedUsageMaxDataPoint adds a data point to mongodbatlas.process.cpu.children.normalized.usage.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUChildrenNormalizedUsageMaxDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasProcessCPUChildrenNormalizedUsageMax.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUChildrenNormalizedUsageMaxDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasProcessCPUChildrenNormalizedUsageMax.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasProcessCPUChildrenUsageAverageDataPoint adds a data point to mongodbatlas.process.cpu.children.usage.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUChildrenUsageAverageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasProcessCPUChildrenUsageAverage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUChildrenUsageAverageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasProcessCPUChildrenUsageAverage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasProcessCPUChildrenUsageMaxDataPoint adds a data point to mongodbatlas.process.cpu.children.usage.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUChildrenUsageMaxDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasProcessCPUChildrenUsageMax.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUChildrenUsageMaxDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasProcessCPUChildrenUsageMax.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasProcessCPUNormalizedUsageAverageDataPoint adds a data point to mongodbatlas.process.cpu.normalized.usage.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUNormalizedUsageAverageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasProcessCPUNormalizedUsageAverage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUNormalizedUsageAverageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasProcessCPUNormalizedUsageAverage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasProcessCPUNormalizedUsageMaxDataPoint adds a data point to mongodbatlas.process.cpu.normalized.usage.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUNormalizedUsageMaxDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasProcessCPUNormalizedUsageMax.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUNormalizedUsageMaxDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasProcessCPUNormalizedUsageMax.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasProcessCPUUsageAverageDataPoint adds a data point to mongodbatlas.process.cpu.usage.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUUsageAverageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasProcessCPUUsageAverage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUUsageAverageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasProcessCPUUsageAverage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasProcessCPUUsageMaxDataPoint adds a data point to mongodbatlas.process.cpu.usage.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUUsageMaxDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasProcessCPUUsageMax.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessCPUUsageMaxDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasProcessCPUUsageMax.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasProcessCursorsDataPoint adds a data point to mongodbatlas.process.cursors metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessCursorsDataPoint(ts pcommon.Timestamp, val float64, cursorStateAttributeValue string) { - mb.metricMongodbatlasProcessCursors.recordDataPoint(mb.startTime, ts, val, cursorStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessCursorsDataPoint(ts pcommon.Timestamp, val float64, cursorStateAttributeValue AttributeCursorState) { + mb.metricMongodbatlasProcessCursors.recordDataPoint(mb.startTime, ts, val, cursorStateAttributeValue.String()) } // RecordMongodbatlasProcessDbDocumentRateDataPoint adds a data point to mongodbatlas.process.db.document.rate metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessDbDocumentRateDataPoint(ts pcommon.Timestamp, val float64, documentStatusAttributeValue string) { - mb.metricMongodbatlasProcessDbDocumentRate.recordDataPoint(mb.startTime, ts, val, documentStatusAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessDbDocumentRateDataPoint(ts pcommon.Timestamp, val float64, documentStatusAttributeValue AttributeDocumentStatus) { + mb.metricMongodbatlasProcessDbDocumentRate.recordDataPoint(mb.startTime, ts, val, documentStatusAttributeValue.String()) } // RecordMongodbatlasProcessDbOperationsRateDataPoint adds a data point to mongodbatlas.process.db.operations.rate metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessDbOperationsRateDataPoint(ts pcommon.Timestamp, val float64, operationAttributeValue string, clusterRoleAttributeValue string) { - mb.metricMongodbatlasProcessDbOperationsRate.recordDataPoint(mb.startTime, ts, val, operationAttributeValue, clusterRoleAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessDbOperationsRateDataPoint(ts pcommon.Timestamp, val float64, operationAttributeValue AttributeOperation, clusterRoleAttributeValue AttributeClusterRole) { + mb.metricMongodbatlasProcessDbOperationsRate.recordDataPoint(mb.startTime, ts, val, operationAttributeValue.String(), clusterRoleAttributeValue.String()) } // RecordMongodbatlasProcessDbOperationsTimeDataPoint adds a data point to mongodbatlas.process.db.operations.time metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessDbOperationsTimeDataPoint(ts pcommon.Timestamp, val float64, executionTypeAttributeValue string) { - mb.metricMongodbatlasProcessDbOperationsTime.recordDataPoint(mb.startTime, ts, val, executionTypeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessDbOperationsTimeDataPoint(ts pcommon.Timestamp, val float64, executionTypeAttributeValue AttributeExecutionType) { + mb.metricMongodbatlasProcessDbOperationsTime.recordDataPoint(mb.startTime, ts, val, executionTypeAttributeValue.String()) } // RecordMongodbatlasProcessDbQueryExecutorScannedDataPoint adds a data point to mongodbatlas.process.db.query_executor.scanned metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessDbQueryExecutorScannedDataPoint(ts pcommon.Timestamp, val float64, scannedTypeAttributeValue string) { - mb.metricMongodbatlasProcessDbQueryExecutorScanned.recordDataPoint(mb.startTime, ts, val, scannedTypeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessDbQueryExecutorScannedDataPoint(ts pcommon.Timestamp, val float64, scannedTypeAttributeValue AttributeScannedType) { + mb.metricMongodbatlasProcessDbQueryExecutorScanned.recordDataPoint(mb.startTime, ts, val, scannedTypeAttributeValue.String()) } // RecordMongodbatlasProcessDbQueryTargetingScannedPerReturnedDataPoint adds a data point to mongodbatlas.process.db.query_targeting.scanned_per_returned metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessDbQueryTargetingScannedPerReturnedDataPoint(ts pcommon.Timestamp, val float64, scannedTypeAttributeValue string) { - mb.metricMongodbatlasProcessDbQueryTargetingScannedPerReturned.recordDataPoint(mb.startTime, ts, val, scannedTypeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessDbQueryTargetingScannedPerReturnedDataPoint(ts pcommon.Timestamp, val float64, scannedTypeAttributeValue AttributeScannedType) { + mb.metricMongodbatlasProcessDbQueryTargetingScannedPerReturned.recordDataPoint(mb.startTime, ts, val, scannedTypeAttributeValue.String()) } // RecordMongodbatlasProcessDbStorageDataPoint adds a data point to mongodbatlas.process.db.storage metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessDbStorageDataPoint(ts pcommon.Timestamp, val float64, storageStatusAttributeValue string) { - mb.metricMongodbatlasProcessDbStorage.recordDataPoint(mb.startTime, ts, val, storageStatusAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessDbStorageDataPoint(ts pcommon.Timestamp, val float64, storageStatusAttributeValue AttributeStorageStatus) { + mb.metricMongodbatlasProcessDbStorage.recordDataPoint(mb.startTime, ts, val, storageStatusAttributeValue.String()) } // RecordMongodbatlasProcessFtsCPUUsageDataPoint adds a data point to mongodbatlas.process.fts.cpu.usage metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessFtsCPUUsageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasProcessFtsCPUUsage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessFtsCPUUsageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasProcessFtsCPUUsage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasProcessGlobalLockDataPoint adds a data point to mongodbatlas.process.global_lock metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessGlobalLockDataPoint(ts pcommon.Timestamp, val float64, globalLockStateAttributeValue string) { - mb.metricMongodbatlasProcessGlobalLock.recordDataPoint(mb.startTime, ts, val, globalLockStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessGlobalLockDataPoint(ts pcommon.Timestamp, val float64, globalLockStateAttributeValue AttributeGlobalLockState) { + mb.metricMongodbatlasProcessGlobalLock.recordDataPoint(mb.startTime, ts, val, globalLockStateAttributeValue.String()) } // RecordMongodbatlasProcessIndexBtreeMissRatioDataPoint adds a data point to mongodbatlas.process.index.btree_miss_ratio metric. @@ -3979,8 +4699,8 @@ func (mb *MetricsBuilder) RecordMongodbatlasProcessIndexBtreeMissRatioDataPoint( } // RecordMongodbatlasProcessIndexCountersDataPoint adds a data point to mongodbatlas.process.index.counters metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessIndexCountersDataPoint(ts pcommon.Timestamp, val float64, btreeCounterTypeAttributeValue string) { - mb.metricMongodbatlasProcessIndexCounters.recordDataPoint(mb.startTime, ts, val, btreeCounterTypeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessIndexCountersDataPoint(ts pcommon.Timestamp, val float64, btreeCounterTypeAttributeValue AttributeBtreeCounterType) { + mb.metricMongodbatlasProcessIndexCounters.recordDataPoint(mb.startTime, ts, val, btreeCounterTypeAttributeValue.String()) } // RecordMongodbatlasProcessJournalingCommitsDataPoint adds a data point to mongodbatlas.process.journaling.commits metric. @@ -3999,13 +4719,13 @@ func (mb *MetricsBuilder) RecordMongodbatlasProcessJournalingWrittenDataPoint(ts } // RecordMongodbatlasProcessMemoryUsageDataPoint adds a data point to mongodbatlas.process.memory.usage metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessMemoryUsageDataPoint(ts pcommon.Timestamp, val float64, memoryStateAttributeValue string) { - mb.metricMongodbatlasProcessMemoryUsage.recordDataPoint(mb.startTime, ts, val, memoryStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessMemoryUsageDataPoint(ts pcommon.Timestamp, val float64, memoryStateAttributeValue AttributeMemoryState) { + mb.metricMongodbatlasProcessMemoryUsage.recordDataPoint(mb.startTime, ts, val, memoryStateAttributeValue.String()) } // RecordMongodbatlasProcessNetworkIoDataPoint adds a data point to mongodbatlas.process.network.io metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessNetworkIoDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue string) { - mb.metricMongodbatlasProcessNetworkIo.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessNetworkIoDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue AttributeDirection) { + mb.metricMongodbatlasProcessNetworkIo.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordMongodbatlasProcessNetworkRequestsDataPoint adds a data point to mongodbatlas.process.network.requests metric. @@ -4019,13 +4739,13 @@ func (mb *MetricsBuilder) RecordMongodbatlasProcessOplogRateDataPoint(ts pcommon } // RecordMongodbatlasProcessOplogTimeDataPoint adds a data point to mongodbatlas.process.oplog.time metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessOplogTimeDataPoint(ts pcommon.Timestamp, val float64, oplogTypeAttributeValue string) { - mb.metricMongodbatlasProcessOplogTime.recordDataPoint(mb.startTime, ts, val, oplogTypeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessOplogTimeDataPoint(ts pcommon.Timestamp, val float64, oplogTypeAttributeValue AttributeOplogType) { + mb.metricMongodbatlasProcessOplogTime.recordDataPoint(mb.startTime, ts, val, oplogTypeAttributeValue.String()) } // RecordMongodbatlasProcessPageFaultsDataPoint adds a data point to mongodbatlas.process.page_faults metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessPageFaultsDataPoint(ts pcommon.Timestamp, val float64, memoryIssueTypeAttributeValue string) { - mb.metricMongodbatlasProcessPageFaults.recordDataPoint(mb.startTime, ts, val, memoryIssueTypeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessPageFaultsDataPoint(ts pcommon.Timestamp, val float64, memoryIssueTypeAttributeValue AttributeMemoryIssueType) { + mb.metricMongodbatlasProcessPageFaults.recordDataPoint(mb.startTime, ts, val, memoryIssueTypeAttributeValue.String()) } // RecordMongodbatlasProcessRestartsDataPoint adds a data point to mongodbatlas.process.restarts metric. @@ -4034,38 +4754,38 @@ func (mb *MetricsBuilder) RecordMongodbatlasProcessRestartsDataPoint(ts pcommon. } // RecordMongodbatlasProcessTicketsDataPoint adds a data point to mongodbatlas.process.tickets metric. -func (mb *MetricsBuilder) RecordMongodbatlasProcessTicketsDataPoint(ts pcommon.Timestamp, val float64, ticketTypeAttributeValue string) { - mb.metricMongodbatlasProcessTickets.recordDataPoint(mb.startTime, ts, val, ticketTypeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasProcessTicketsDataPoint(ts pcommon.Timestamp, val float64, ticketTypeAttributeValue AttributeTicketType) { + mb.metricMongodbatlasProcessTickets.recordDataPoint(mb.startTime, ts, val, ticketTypeAttributeValue.String()) } // RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint adds a data point to mongodbatlas.system.cpu.normalized.usage.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasSystemCPUNormalizedUsageAverage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasSystemCPUNormalizedUsageAverage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint adds a data point to mongodbatlas.system.cpu.normalized.usage.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasSystemCPUNormalizedUsageMax.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasSystemCPUNormalizedUsageMax.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasSystemCPUUsageAverageDataPoint adds a data point to mongodbatlas.system.cpu.usage.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasSystemCPUUsageAverage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasSystemCPUUsageAverage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasSystemCPUUsageMaxDataPoint adds a data point to mongodbatlas.system.cpu.usage.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasSystemCPUUsageMax.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasSystemCPUUsageMax.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasSystemFtsCPUNormalizedUsageDataPoint adds a data point to mongodbatlas.system.fts.cpu.normalized.usage metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemFtsCPUNormalizedUsageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasSystemFtsCPUNormalizedUsage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemFtsCPUNormalizedUsageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasSystemFtsCPUNormalizedUsage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasSystemFtsCPUUsageDataPoint adds a data point to mongodbatlas.system.fts.cpu.usage metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemFtsCPUUsageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue string) { - mb.metricMongodbatlasSystemFtsCPUUsage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemFtsCPUUsageDataPoint(ts pcommon.Timestamp, val float64, cpuStateAttributeValue AttributeCPUState) { + mb.metricMongodbatlasSystemFtsCPUUsage.recordDataPoint(mb.startTime, ts, val, cpuStateAttributeValue.String()) } // RecordMongodbatlasSystemFtsDiskUsedDataPoint adds a data point to mongodbatlas.system.fts.disk.used metric. @@ -4074,48 +4794,48 @@ func (mb *MetricsBuilder) RecordMongodbatlasSystemFtsDiskUsedDataPoint(ts pcommo } // RecordMongodbatlasSystemFtsMemoryUsageDataPoint adds a data point to mongodbatlas.system.fts.memory.usage metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemFtsMemoryUsageDataPoint(ts pcommon.Timestamp, val float64, memoryStateAttributeValue string) { - mb.metricMongodbatlasSystemFtsMemoryUsage.recordDataPoint(mb.startTime, ts, val, memoryStateAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemFtsMemoryUsageDataPoint(ts pcommon.Timestamp, val float64, memoryStateAttributeValue AttributeMemoryState) { + mb.metricMongodbatlasSystemFtsMemoryUsage.recordDataPoint(mb.startTime, ts, val, memoryStateAttributeValue.String()) } // RecordMongodbatlasSystemMemoryUsageAverageDataPoint adds a data point to mongodbatlas.system.memory.usage.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts pcommon.Timestamp, val float64, memoryStatusAttributeValue string) { - mb.metricMongodbatlasSystemMemoryUsageAverage.recordDataPoint(mb.startTime, ts, val, memoryStatusAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts pcommon.Timestamp, val float64, memoryStatusAttributeValue AttributeMemoryStatus) { + mb.metricMongodbatlasSystemMemoryUsageAverage.recordDataPoint(mb.startTime, ts, val, memoryStatusAttributeValue.String()) } // RecordMongodbatlasSystemMemoryUsageMaxDataPoint adds a data point to mongodbatlas.system.memory.usage.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemMemoryUsageMaxDataPoint(ts pcommon.Timestamp, val float64, memoryStatusAttributeValue string) { - mb.metricMongodbatlasSystemMemoryUsageMax.recordDataPoint(mb.startTime, ts, val, memoryStatusAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemMemoryUsageMaxDataPoint(ts pcommon.Timestamp, val float64, memoryStatusAttributeValue AttributeMemoryStatus) { + mb.metricMongodbatlasSystemMemoryUsageMax.recordDataPoint(mb.startTime, ts, val, memoryStatusAttributeValue.String()) } // RecordMongodbatlasSystemNetworkIoAverageDataPoint adds a data point to mongodbatlas.system.network.io.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemNetworkIoAverageDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue string) { - mb.metricMongodbatlasSystemNetworkIoAverage.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemNetworkIoAverageDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue AttributeDirection) { + mb.metricMongodbatlasSystemNetworkIoAverage.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordMongodbatlasSystemNetworkIoMaxDataPoint adds a data point to mongodbatlas.system.network.io.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemNetworkIoMaxDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue string) { - mb.metricMongodbatlasSystemNetworkIoMax.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemNetworkIoMaxDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue AttributeDirection) { + mb.metricMongodbatlasSystemNetworkIoMax.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordMongodbatlasSystemPagingIoAverageDataPoint adds a data point to mongodbatlas.system.paging.io.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemPagingIoAverageDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue string) { - mb.metricMongodbatlasSystemPagingIoAverage.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemPagingIoAverageDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue AttributeDirection) { + mb.metricMongodbatlasSystemPagingIoAverage.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordMongodbatlasSystemPagingIoMaxDataPoint adds a data point to mongodbatlas.system.paging.io.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemPagingIoMaxDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue string) { - mb.metricMongodbatlasSystemPagingIoMax.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemPagingIoMaxDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue AttributeDirection) { + mb.metricMongodbatlasSystemPagingIoMax.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordMongodbatlasSystemPagingUsageAverageDataPoint adds a data point to mongodbatlas.system.paging.usage.average metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemPagingUsageAverageDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue string) { - mb.metricMongodbatlasSystemPagingUsageAverage.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemPagingUsageAverageDataPoint(ts pcommon.Timestamp, val float64, memoryStateAttributeValue AttributeMemoryState) { + mb.metricMongodbatlasSystemPagingUsageAverage.recordDataPoint(mb.startTime, ts, val, memoryStateAttributeValue.String()) } // RecordMongodbatlasSystemPagingUsageMaxDataPoint adds a data point to mongodbatlas.system.paging.usage.max metric. -func (mb *MetricsBuilder) RecordMongodbatlasSystemPagingUsageMaxDataPoint(ts pcommon.Timestamp, val float64, directionAttributeValue string) { - mb.metricMongodbatlasSystemPagingUsageMax.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordMongodbatlasSystemPagingUsageMaxDataPoint(ts pcommon.Timestamp, val float64, memoryStateAttributeValue AttributeMemoryState) { + mb.metricMongodbatlasSystemPagingUsageMax.recordDataPoint(mb.startTime, ts, val, memoryStateAttributeValue.String()) } // Reset resets metrics builder to its initial state. It should be used when external metrics source is restarted, @@ -4200,275 +4920,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeAssertType are the possible values that the attribute "assert_type" can have. -var AttributeAssertType = struct { - Regular string - Warning string - Msg string - User string -}{ - "regular", - "warning", - "msg", - "user", -} - -// AttributeBtreeCounterType are the possible values that the attribute "btree_counter_type" can have. -var AttributeBtreeCounterType = struct { - Accesses string - Hits string - Misses string -}{ - "accesses", - "hits", - "misses", -} - -// AttributeCacheDirection are the possible values that the attribute "cache_direction" can have. -var AttributeCacheDirection = struct { - ReadInto string - WrittenFrom string -}{ - "read_into", - "written_from", -} - -// AttributeCacheStatus are the possible values that the attribute "cache_status" can have. -var AttributeCacheStatus = struct { - Dirty string - Used string -}{ - "dirty", - "used", -} - -// AttributeClusterRole are the possible values that the attribute "cluster_role" can have. -var AttributeClusterRole = struct { - Primary string - Replica string -}{ - "primary", - "replica", -} - -// AttributeCPUState are the possible values that the attribute "cpu_state" can have. -var AttributeCPUState = struct { - Kernel string - User string - Nice string - Iowait string - Irq string - Softirq string - Guest string - Steal string -}{ - "kernel", - "user", - "nice", - "iowait", - "irq", - "softirq", - "guest", - "steal", -} - -// AttributeCursorState are the possible values that the attribute "cursor_state" can have. -var AttributeCursorState = struct { - TimedOut string - Open string -}{ - "timed_out", - "open", -} - -// AttributeDirection are the possible values that the attribute "direction" can have. -var AttributeDirection = struct { - Receive string - Transmit string -}{ - "receive", - "transmit", -} - -// AttributeDiskDirection are the possible values that the attribute "disk_direction" can have. -var AttributeDiskDirection = struct { - Read string - Write string - Total string -}{ - "read", - "write", - "total", -} - -// AttributeDiskStatus are the possible values that the attribute "disk_status" can have. -var AttributeDiskStatus = struct { - Free string - Used string -}{ - "free", - "used", -} - -// AttributeDocumentStatus are the possible values that the attribute "document_status" can have. -var AttributeDocumentStatus = struct { - Returned string - Inserted string - Updated string - Deleted string -}{ - "returned", - "inserted", - "updated", - "deleted", -} - -// AttributeExecutionType are the possible values that the attribute "execution_type" can have. -var AttributeExecutionType = struct { - Reads string - Writes string - Commands string -}{ - "reads", - "writes", - "commands", -} - -// AttributeGlobalLockState are the possible values that the attribute "global_lock_state" can have. -var AttributeGlobalLockState = struct { - CurrentQueueTotal string - CurrentQueueReaders string - CurrentQueueWriters string -}{ - "current_queue_total", - "current_queue_readers", - "current_queue_writers", -} - -// AttributeMemoryIssueType are the possible values that the attribute "memory_issue_type" can have. -var AttributeMemoryIssueType = struct { - ExtraInfo string - GlobalAccessesNotInMemory string - ExceptionsThrown string -}{ - "extra_info", - "global_accesses_not_in_memory", - "exceptions_thrown", -} - -// AttributeMemoryState are the possible values that the attribute "memory_state" can have. -var AttributeMemoryState = struct { - Resident string - Virtual string - Mapped string - Computed string - Shared string - Free string - Used string -}{ - "resident", - "virtual", - "mapped", - "computed", - "shared", - "free", - "used", -} - -// AttributeMemoryStatus are the possible values that the attribute "memory_status" can have. -var AttributeMemoryStatus = struct { - Available string - Buffers string - Cached string - Free string - Shared string - Used string -}{ - "available", - "buffers", - "cached", - "free", - "shared", - "used", -} - -// AttributeObjectType are the possible values that the attribute "object_type" can have. -var AttributeObjectType = struct { - Collection string - Index string - Extent string - Object string - View string - Storage string - Data string -}{ - "collection", - "index", - "extent", - "object", - "view", - "storage", - "data", -} - -// AttributeOperation are the possible values that the attribute "operation" can have. -var AttributeOperation = struct { - Cmd string - Query string - Update string - Delete string - Getmore string - Insert string - ScanAndOrder string -}{ - "cmd", - "query", - "update", - "delete", - "getmore", - "insert", - "scan_and_order", -} - -// AttributeOplogType are the possible values that the attribute "oplog_type" can have. -var AttributeOplogType = struct { - SlaveLagMasterTime string - MasterTime string - MasterLagTimeDiff string -}{ - "slave_lag_master_time", - "master_time", - "master_lag_time_diff", -} - -// AttributeScannedType are the possible values that the attribute "scanned_type" can have. -var AttributeScannedType = struct { - IndexItems string - Objects string -}{ - "index_items", - "objects", -} - -// AttributeStorageStatus are the possible values that the attribute "storage_status" can have. -var AttributeStorageStatus = struct { - Total string - DataSize string - IndexSize string - DataSizeWoSystem string -}{ - "total", - "data_size", - "index_size", - "data_size_wo_system", -} - -// AttributeTicketType are the possible values that the attribute "ticket_type" can have. -var AttributeTicketType = struct { - AvailableReads string - AvailableWrites string -}{ - "available_reads", - "available_writes", -} diff --git a/receiver/mongodbatlasreceiver/internal/metadata/metric_name_mapping.go b/receiver/mongodbatlasreceiver/internal/metadata/metric_name_mapping.go index 588d89a11139..b9c89d38daac 100644 --- a/receiver/mongodbatlasreceiver/internal/metadata/metric_name_mapping.go +++ b/receiver/mongodbatlasreceiver/internal/metadata/metric_name_mapping.go @@ -31,107 +31,107 @@ func getRecordFunc(metricName string) metricRecordFunc { case "PROCESS_CPU_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasProcessCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "MAX_PROCESS_CPU_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasProcessCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "PROCESS_CPU_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasProcessCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } case "MAX_PROCESS_CPU_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasProcessCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } case "PROCESS_CPU_CHILDREN_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUChildrenUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasProcessCPUChildrenUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "MAX_PROCESS_CPU_CHILDREN_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUChildrenUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasProcessCPUChildrenUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "PROCESS_CPU_CHILDREN_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUChildrenUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasProcessCPUChildrenUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } case "MAX_PROCESS_CPU_CHILDREN_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUChildrenUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasProcessCPUChildrenUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } // MongoDB CPU usage scaled to a range of 0% to 100%. Atlas computes this value by dividing by the number of CPU cores. case "PROCESS_NORMALIZED_CPU_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasProcessCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "MAX_PROCESS_NORMALIZED_CPU_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasProcessCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "PROCESS_NORMALIZED_CPU_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasProcessCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } case "MAX_PROCESS_NORMALIZED_CPU_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasProcessCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } case "PROCESS_NORMALIZED_CPU_CHILDREN_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUChildrenNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasProcessCPUChildrenNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } // Context: Process case "MAX_PROCESS_NORMALIZED_CPU_CHILDREN_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUChildrenNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasProcessCPUChildrenNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "PROCESS_NORMALIZED_CPU_CHILDREN_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUChildrenNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasProcessCPUChildrenNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } case "MAX_PROCESS_NORMALIZED_CPU_CHILDREN_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCPUChildrenNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasProcessCPUChildrenNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } // Rate of asserts for a MongoDB process found in the asserts document that the serverStatus command generates. case "ASSERT_REGULAR": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessAssertsDataPoint(ts, float64(*dp.Value), AttributeAssertType.Regular) + mb.RecordMongodbatlasProcessAssertsDataPoint(ts, float64(*dp.Value), AttributeAssertTypeRegular) } case "ASSERT_WARNING": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessAssertsDataPoint(ts, float64(*dp.Value), AttributeAssertType.Warning) + mb.RecordMongodbatlasProcessAssertsDataPoint(ts, float64(*dp.Value), AttributeAssertTypeWarning) } case "ASSERT_MSG": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessAssertsDataPoint(ts, float64(*dp.Value), AttributeAssertType.Msg) + mb.RecordMongodbatlasProcessAssertsDataPoint(ts, float64(*dp.Value), AttributeAssertTypeMsg) } case "ASSERT_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessAssertsDataPoint(ts, float64(*dp.Value), AttributeAssertType.User) + mb.RecordMongodbatlasProcessAssertsDataPoint(ts, float64(*dp.Value), AttributeAssertTypeUser) } // Amount of data flushed in the background. @@ -145,32 +145,32 @@ func getRecordFunc(metricName string) metricRecordFunc { case "CACHE_BYTES_READ_INTO": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCacheIoDataPoint(ts, float64(*dp.Value), AttributeCacheDirection.ReadInto) + mb.RecordMongodbatlasProcessCacheIoDataPoint(ts, float64(*dp.Value), AttributeCacheDirectionReadInto) } case "CACHE_BYTES_WRITTEN_FROM": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCacheIoDataPoint(ts, float64(*dp.Value), AttributeCacheDirection.WrittenFrom) + mb.RecordMongodbatlasProcessCacheIoDataPoint(ts, float64(*dp.Value), AttributeCacheDirectionWrittenFrom) } case "CACHE_DIRTY_BYTES": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCacheSizeDataPoint(ts, float64(*dp.Value), AttributeCacheStatus.Dirty) + mb.RecordMongodbatlasProcessCacheSizeDataPoint(ts, float64(*dp.Value), AttributeCacheStatusDirty) } case "CACHE_USED_BYTES": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCacheSizeDataPoint(ts, float64(*dp.Value), AttributeCacheStatus.Used) + mb.RecordMongodbatlasProcessCacheSizeDataPoint(ts, float64(*dp.Value), AttributeCacheStatusUsed) } case "TICKETS_AVAILABLE_READS": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessTicketsDataPoint(ts, float64(*dp.Value), AttributeTicketType.AvailableReads) + mb.RecordMongodbatlasProcessTicketsDataPoint(ts, float64(*dp.Value), AttributeTicketTypeAvailableReads) } case "TICKETS_AVAILABLE_WRITE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessTicketsDataPoint(ts, float64(*dp.Value), AttributeTicketType.AvailableWrites) + mb.RecordMongodbatlasProcessTicketsDataPoint(ts, float64(*dp.Value), AttributeTicketTypeAvailableWrites) } // Number of connections to a MongoDB process found in the connections document that the serverStatus command generates. @@ -182,55 +182,55 @@ func getRecordFunc(metricName string) metricRecordFunc { // Number of cursors for a MongoDB process found in the metrics.cursor document that the serverStatus command generates. case "CURSORS_TOTAL_OPEN": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCursorsDataPoint(ts, float64(*dp.Value), AttributeCursorState.Open) + mb.RecordMongodbatlasProcessCursorsDataPoint(ts, float64(*dp.Value), AttributeCursorStateOpen) } case "CURSORS_TOTAL_TIMED_OUT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessCursorsDataPoint(ts, float64(*dp.Value), AttributeCursorState.TimedOut) + mb.RecordMongodbatlasProcessCursorsDataPoint(ts, float64(*dp.Value), AttributeCursorStateTimedOut) } // Numbers of Memory Issues and Page Faults for a MongoDB process. case "EXTRA_INFO_PAGE_FAULTS": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessPageFaultsDataPoint(ts, float64(*dp.Value), AttributeMemoryIssueType.ExtraInfo) + mb.RecordMongodbatlasProcessPageFaultsDataPoint(ts, float64(*dp.Value), AttributeMemoryIssueTypeExtraInfo) } case "GLOBAL_ACCESSES_NOT_IN_MEMORY": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessPageFaultsDataPoint(ts, float64(*dp.Value), AttributeMemoryIssueType.GlobalAccessesNotInMemory) + mb.RecordMongodbatlasProcessPageFaultsDataPoint(ts, float64(*dp.Value), AttributeMemoryIssueTypeGlobalAccessesNotInMemory) } case "GLOBAL_PAGE_FAULT_EXCEPTIONS_THROWN": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessPageFaultsDataPoint(ts, float64(*dp.Value), AttributeMemoryIssueType.ExceptionsThrown) + mb.RecordMongodbatlasProcessPageFaultsDataPoint(ts, float64(*dp.Value), AttributeMemoryIssueTypeExceptionsThrown) } // Number of operations waiting on locks for the MongoDB process that the serverStatus command generates. Cloud Manager computes these values based on the type of storage engine. case "GLOBAL_LOCK_CURRENT_QUEUE_TOTAL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessGlobalLockDataPoint(ts, float64(*dp.Value), AttributeGlobalLockState.CurrentQueueTotal) + mb.RecordMongodbatlasProcessGlobalLockDataPoint(ts, float64(*dp.Value), AttributeGlobalLockStateCurrentQueueTotal) } case "GLOBAL_LOCK_CURRENT_QUEUE_READERS": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessGlobalLockDataPoint(ts, float64(*dp.Value), AttributeGlobalLockState.CurrentQueueReaders) + mb.RecordMongodbatlasProcessGlobalLockDataPoint(ts, float64(*dp.Value), AttributeGlobalLockStateCurrentQueueReaders) } case "GLOBAL_LOCK_CURRENT_QUEUE_WRITERS": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessGlobalLockDataPoint(ts, float64(*dp.Value), AttributeGlobalLockState.CurrentQueueWriters) + mb.RecordMongodbatlasProcessGlobalLockDataPoint(ts, float64(*dp.Value), AttributeGlobalLockStateCurrentQueueWriters) } // Number of index btree operations. case "INDEX_COUNTERS_BTREE_ACCESSES": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessIndexCountersDataPoint(ts, float64(*dp.Value), AttributeBtreeCounterType.Accesses) + mb.RecordMongodbatlasProcessIndexCountersDataPoint(ts, float64(*dp.Value), AttributeBtreeCounterTypeAccesses) } case "INDEX_COUNTERS_BTREE_HITS": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessIndexCountersDataPoint(ts, float64(*dp.Value), AttributeBtreeCounterType.Hits) + mb.RecordMongodbatlasProcessIndexCountersDataPoint(ts, float64(*dp.Value), AttributeBtreeCounterTypeHits) } case "INDEX_COUNTERS_BTREE_MISSES": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessIndexCountersDataPoint(ts, float64(*dp.Value), AttributeBtreeCounterType.Misses) + mb.RecordMongodbatlasProcessIndexCountersDataPoint(ts, float64(*dp.Value), AttributeBtreeCounterTypeMisses) } case "INDEX_COUNTERS_BTREE_MISS_RATIO": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { @@ -254,31 +254,31 @@ func getRecordFunc(metricName string) metricRecordFunc { // Amount of memory for a MongoDB process found in the mem document that the serverStatus command collects. case "MEMORY_RESIDENT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryState.Resident) + mb.RecordMongodbatlasProcessMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryStateResident) } case "MEMORY_VIRTUAL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryState.Virtual) + mb.RecordMongodbatlasProcessMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryStateVirtual) } case "MEMORY_MAPPED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryState.Mapped) + mb.RecordMongodbatlasProcessMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryStateMapped) } case "COMPUTED_MEMORY": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryState.Computed) + mb.RecordMongodbatlasProcessMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryStateComputed) } // Amount of throughput for MongoDB process found in the network document that the serverStatus command collects. case "NETWORK_BYTES_IN": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessNetworkIoDataPoint(ts, float64(*dp.Value), AttributeDirection.Receive) + mb.RecordMongodbatlasProcessNetworkIoDataPoint(ts, float64(*dp.Value), AttributeDirectionReceive) } case "NETWORK_BYTES_OUT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessNetworkIoDataPoint(ts, float64(*dp.Value), AttributeDirection.Transmit) + mb.RecordMongodbatlasProcessNetworkIoDataPoint(ts, float64(*dp.Value), AttributeDirectionTransmit) } case "NETWORK_NUM_REQUESTS": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { @@ -288,15 +288,15 @@ func getRecordFunc(metricName string) metricRecordFunc { // Durations and throughput of the MongoDB process' oplog. case "OPLOG_SLAVE_LAG_MASTER_TIME": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessOplogTimeDataPoint(ts, float64(*dp.Value), AttributeOplogType.SlaveLagMasterTime) + mb.RecordMongodbatlasProcessOplogTimeDataPoint(ts, float64(*dp.Value), AttributeOplogTypeSlaveLagMasterTime) } case "OPLOG_MASTER_TIME": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessOplogTimeDataPoint(ts, float64(*dp.Value), AttributeOplogType.MasterTime) + mb.RecordMongodbatlasProcessOplogTimeDataPoint(ts, float64(*dp.Value), AttributeOplogTypeMasterTime) } case "OPLOG_MASTER_LAG_TIME_DIFF": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessOplogTimeDataPoint(ts, float64(*dp.Value), AttributeOplogType.MasterLagTimeDiff) + mb.RecordMongodbatlasProcessOplogTimeDataPoint(ts, float64(*dp.Value), AttributeOplogTypeMasterLagTimeDiff) } case "OPLOG_RATE_GB_PER_HOUR": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { @@ -307,102 +307,102 @@ func getRecordFunc(metricName string) metricRecordFunc { case "DB_STORAGE_TOTAL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbStorageDataPoint(ts, float64(*dp.Value), AttributeStorageStatus.Total) + mb.RecordMongodbatlasProcessDbStorageDataPoint(ts, float64(*dp.Value), AttributeStorageStatusTotal) } case "DB_DATA_SIZE_TOTAL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbStorageDataPoint(ts, float64(*dp.Value), AttributeStorageStatus.DataSize) + mb.RecordMongodbatlasProcessDbStorageDataPoint(ts, float64(*dp.Value), AttributeStorageStatusDataSize) } case "DB_INDEX_SIZE_TOTAL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbStorageDataPoint(ts, float64(*dp.Value), AttributeStorageStatus.IndexSize) + mb.RecordMongodbatlasProcessDbStorageDataPoint(ts, float64(*dp.Value), AttributeStorageStatusIndexSize) } case "DB_DATA_SIZE_TOTAL_WO_SYSTEM": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbStorageDataPoint(ts, float64(*dp.Value), AttributeStorageStatus.DataSizeWoSystem) + mb.RecordMongodbatlasProcessDbStorageDataPoint(ts, float64(*dp.Value), AttributeStorageStatusDataSizeWoSystem) } // Rate of database operations on a MongoDB process since the process last started found in the opcounters document that the serverStatus command collects. case "OPCOUNTER_CMD": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperation.Cmd, AttributeClusterRole.Primary) + mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperationCmd, AttributeClusterRolePrimary) } case "OPCOUNTER_QUERY": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperation.Query, AttributeClusterRole.Primary) + mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperationQuery, AttributeClusterRolePrimary) } case "OPCOUNTER_UPDATE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperation.Update, AttributeClusterRole.Primary) + mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperationUpdate, AttributeClusterRolePrimary) } case "OPCOUNTER_DELETE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperation.Delete, AttributeClusterRole.Primary) + mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperationDelete, AttributeClusterRolePrimary) } case "OPCOUNTER_GETMORE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperation.Getmore, AttributeClusterRole.Primary) + mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperationGetmore, AttributeClusterRolePrimary) } case "OPCOUNTER_INSERT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperation.Insert, AttributeClusterRole.Primary) + mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperationInsert, AttributeClusterRolePrimary) } // Rate of database operations on MongoDB secondaries found in the opcountersRepl document that the serverStatus command collects. case "OPCOUNTER_REPL_CMD": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperation.Cmd, AttributeClusterRole.Replica) + mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperationCmd, AttributeClusterRoleReplica) } case "OPCOUNTER_REPL_UPDATE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperation.Update, AttributeClusterRole.Replica) + mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperationUpdate, AttributeClusterRoleReplica) } case "OPCOUNTER_REPL_DELETE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperation.Delete, AttributeClusterRole.Replica) + mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperationDelete, AttributeClusterRoleReplica) } case "OPCOUNTER_REPL_INSERT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperation.Insert, AttributeClusterRole.Replica) + mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperationInsert, AttributeClusterRoleReplica) } // Average rate of documents returned, inserted, updated, or deleted per second during a selected time period. case "DOCUMENT_METRICS_RETURNED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbDocumentRateDataPoint(ts, float64(*dp.Value), AttributeDocumentStatus.Returned) + mb.RecordMongodbatlasProcessDbDocumentRateDataPoint(ts, float64(*dp.Value), AttributeDocumentStatusReturned) } case "DOCUMENT_METRICS_INSERTED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbDocumentRateDataPoint(ts, float64(*dp.Value), AttributeDocumentStatus.Inserted) + mb.RecordMongodbatlasProcessDbDocumentRateDataPoint(ts, float64(*dp.Value), AttributeDocumentStatusInserted) } case "DOCUMENT_METRICS_UPDATED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbDocumentRateDataPoint(ts, float64(*dp.Value), AttributeDocumentStatus.Updated) + mb.RecordMongodbatlasProcessDbDocumentRateDataPoint(ts, float64(*dp.Value), AttributeDocumentStatusUpdated) } case "DOCUMENT_METRICS_DELETED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbDocumentRateDataPoint(ts, float64(*dp.Value), AttributeDocumentStatus.Deleted) + mb.RecordMongodbatlasProcessDbDocumentRateDataPoint(ts, float64(*dp.Value), AttributeDocumentStatusDeleted) } // Average rate for operations per second during a selected time period that perform a sort but cannot perform the sort using an index. case "OPERATIONS_SCAN_AND_ORDER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperation.ScanAndOrder, AttributeClusterRole.Primary) + mb.RecordMongodbatlasProcessDbOperationsRateDataPoint(ts, float64(*dp.Value), AttributeOperationScanAndOrder, AttributeClusterRolePrimary) } // Average execution time in milliseconds per read, write, or command operation during a selected time period. case "OP_EXECUTION_TIME_READS": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsTimeDataPoint(ts, float64(*dp.Value), AttributeExecutionType.Reads) + mb.RecordMongodbatlasProcessDbOperationsTimeDataPoint(ts, float64(*dp.Value), AttributeExecutionTypeReads) } case "OP_EXECUTION_TIME_WRITES": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsTimeDataPoint(ts, float64(*dp.Value), AttributeExecutionType.Writes) + mb.RecordMongodbatlasProcessDbOperationsTimeDataPoint(ts, float64(*dp.Value), AttributeExecutionTypeWrites) } case "OP_EXECUTION_TIME_COMMANDS": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbOperationsTimeDataPoint(ts, float64(*dp.Value), AttributeExecutionType.Commands) + mb.RecordMongodbatlasProcessDbOperationsTimeDataPoint(ts, float64(*dp.Value), AttributeExecutionTypeCommands) } // Number of times the host restarted within the previous hour. @@ -414,278 +414,278 @@ func getRecordFunc(metricName string) metricRecordFunc { // Average rate per second to scan index items during queries and query-plan evaluations found in the value of totalKeysExamined from the explain command. case "QUERY_EXECUTOR_SCANNED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbQueryExecutorScannedDataPoint(ts, float64(*dp.Value), AttributeScannedType.IndexItems) + mb.RecordMongodbatlasProcessDbQueryExecutorScannedDataPoint(ts, float64(*dp.Value), AttributeScannedTypeIndexItems) } // Average rate of documents scanned per second during queries and query-plan evaluations found in the value of totalDocsExamined from the explain command. case "QUERY_EXECUTOR_SCANNED_OBJECTS": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbQueryExecutorScannedDataPoint(ts, float64(*dp.Value), AttributeScannedType.Objects) + mb.RecordMongodbatlasProcessDbQueryExecutorScannedDataPoint(ts, float64(*dp.Value), AttributeScannedTypeObjects) } // Ratio of the number of index items scanned to the number of documents returned. case "QUERY_TARGETING_SCANNED_PER_RETURNED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbQueryTargetingScannedPerReturnedDataPoint(ts, float64(*dp.Value), AttributeScannedType.IndexItems) + mb.RecordMongodbatlasProcessDbQueryTargetingScannedPerReturnedDataPoint(ts, float64(*dp.Value), AttributeScannedTypeIndexItems) } // Ratio of the number of documents scanned to the number of documents returned. case "QUERY_TARGETING_SCANNED_OBJECTS_PER_RETURNED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasProcessDbQueryTargetingScannedPerReturnedDataPoint(ts, float64(*dp.Value), AttributeScannedType.Objects) + mb.RecordMongodbatlasProcessDbQueryTargetingScannedPerReturnedDataPoint(ts, float64(*dp.Value), AttributeScannedTypeObjects) } // CPU usage of processes on the host. For hosts with more than one CPU core, this value can exceed 100%. case "SYSTEM_CPU_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "MAX_SYSTEM_CPU_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "SYSTEM_CPU_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } case "MAX_SYSTEM_CPU_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } case "SYSTEM_CPU_NICE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Nice) + mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateNice) } case "MAX_SYSTEM_CPU_NICE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Nice) + mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateNice) } case "SYSTEM_CPU_IOWAIT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Iowait) + mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateIowait) } case "MAX_SYSTEM_CPU_IOWAIT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Iowait) + mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateIowait) } case "SYSTEM_CPU_IRQ": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Irq) + mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateIrq) } case "MAX_SYSTEM_CPU_IRQ": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Irq) + mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateIrq) } case "SYSTEM_CPU_SOFTIRQ": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Softirq) + mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateSoftirq) } case "MAX_SYSTEM_CPU_SOFTIRQ": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Softirq) + mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateSoftirq) } case "SYSTEM_CPU_GUEST": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Guest) + mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateGuest) } case "MAX_SYSTEM_CPU_GUEST": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Guest) + mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateGuest) } case "SYSTEM_CPU_STEAL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Steal) + mb.RecordMongodbatlasSystemCPUUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateSteal) } case "MAX_SYSTEM_CPU_STEAL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Steal) + mb.RecordMongodbatlasSystemCPUUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateSteal) } // CPU usage of processes on the host scaled to a range of 0 to 100% by dividing by the number of CPU cores. case "SYSTEM_NORMALIZED_CPU_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "MAX_SYSTEM_NORMALIZED_CPU_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "MAX_SYSTEM_NORMALIZED_CPU_NICE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Nice) + mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateNice) } case "SYSTEM_NORMALIZED_CPU_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } case "MAX_SYSTEM_NORMALIZED_CPU_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } case "SYSTEM_NORMALIZED_CPU_NICE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Nice) + mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateNice) } case "SYSTEM_NORMALIZED_CPU_IOWAIT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Iowait) + mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateIowait) } case "MAX_SYSTEM_NORMALIZED_CPU_IOWAIT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Iowait) + mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateIowait) } case "SYSTEM_NORMALIZED_CPU_IRQ": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Irq) + mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateIrq) } case "MAX_SYSTEM_NORMALIZED_CPU_IRQ": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Irq) + mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateIrq) } case "SYSTEM_NORMALIZED_CPU_SOFTIRQ": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Softirq) + mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateSoftirq) } case "MAX_SYSTEM_NORMALIZED_CPU_SOFTIRQ": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Softirq) + mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateSoftirq) } case "SYSTEM_NORMALIZED_CPU_GUEST": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Guest) + mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateGuest) } case "MAX_SYSTEM_NORMALIZED_CPU_GUEST": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Guest) + mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateGuest) } case "SYSTEM_NORMALIZED_CPU_STEAL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Steal) + mb.RecordMongodbatlasSystemCPUNormalizedUsageAverageDataPoint(ts, float64(*dp.Value), AttributeCPUStateSteal) } case "MAX_SYSTEM_NORMALIZED_CPU_STEAL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUState.Steal) + mb.RecordMongodbatlasSystemCPUNormalizedUsageMaxDataPoint(ts, float64(*dp.Value), AttributeCPUStateSteal) } // Physical memory usage, in bytes, that the host uses. case "SYSTEM_MEMORY_AVAILABLE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatus.Available) + mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatusAvailable) } case "MAX_SYSTEM_MEMORY_AVAILABLE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemMemoryUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryStatus.Available) + mb.RecordMongodbatlasSystemMemoryUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryStatusAvailable) } case "SYSTEM_MEMORY_BUFFERS": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatus.Buffers) + mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatusBuffers) } case "MAX_SYSTEM_MEMORY_BUFFERS": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemMemoryUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryStatus.Buffers) + mb.RecordMongodbatlasSystemMemoryUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryStatusBuffers) } case "SYSTEM_MEMORY_CACHED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatus.Cached) + mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatusCached) } case "MAX_SYSTEM_MEMORY_CACHED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemMemoryUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryStatus.Cached) + mb.RecordMongodbatlasSystemMemoryUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryStatusCached) } case "SYSTEM_MEMORY_FREE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatus.Free) + mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatusFree) } case "MAX_SYSTEM_MEMORY_FREE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatus.Free) + mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatusFree) } case "SYSTEM_MEMORY_SHARED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatus.Shared) + mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatusShared) } case "MAX_SYSTEM_MEMORY_SHARED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemMemoryUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryStatus.Shared) + mb.RecordMongodbatlasSystemMemoryUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryStatusShared) } case "SYSTEM_MEMORY_USED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatus.Used) + mb.RecordMongodbatlasSystemMemoryUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStatusUsed) } case "MAX_SYSTEM_MEMORY_USED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemMemoryUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryStatus.Used) + mb.RecordMongodbatlasSystemMemoryUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryStatusUsed) } // Average rate of physical bytes per second that the eth0 network interface received and transmitted. case "SYSTEM_NETWORK_IN": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemNetworkIoAverageDataPoint(ts, float64(*dp.Value), AttributeDirection.Receive) + mb.RecordMongodbatlasSystemNetworkIoAverageDataPoint(ts, float64(*dp.Value), AttributeDirectionReceive) } case "MAX_SYSTEM_NETWORK_IN": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemNetworkIoMaxDataPoint(ts, float64(*dp.Value), AttributeDirection.Receive) + mb.RecordMongodbatlasSystemNetworkIoMaxDataPoint(ts, float64(*dp.Value), AttributeDirectionReceive) } case "SYSTEM_NETWORK_OUT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemNetworkIoAverageDataPoint(ts, float64(*dp.Value), AttributeDirection.Transmit) + mb.RecordMongodbatlasSystemNetworkIoAverageDataPoint(ts, float64(*dp.Value), AttributeDirectionTransmit) } case "MAX_SYSTEM_NETWORK_OUT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemNetworkIoMaxDataPoint(ts, float64(*dp.Value), AttributeDirection.Transmit) + mb.RecordMongodbatlasSystemNetworkIoMaxDataPoint(ts, float64(*dp.Value), AttributeDirectionTransmit) } // Total amount of memory that swap uses. case "SWAP_USAGE_USED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemPagingUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryState.Used) + mb.RecordMongodbatlasSystemPagingUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStateUsed) } case "MAX_SWAP_USAGE_USED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemPagingUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryState.Used) + mb.RecordMongodbatlasSystemPagingUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryStateUsed) } case "SWAP_USAGE_FREE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemPagingUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryState.Free) + mb.RecordMongodbatlasSystemPagingUsageAverageDataPoint(ts, float64(*dp.Value), AttributeMemoryStateFree) } case "MAX_SWAP_USAGE_FREE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemPagingUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryState.Free) + mb.RecordMongodbatlasSystemPagingUsageMaxDataPoint(ts, float64(*dp.Value), AttributeMemoryStateFree) } // Total amount of memory written and read from swap. case "SWAP_IO_IN": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemPagingIoAverageDataPoint(ts, float64(*dp.Value), AttributeDirection.Receive) + mb.RecordMongodbatlasSystemPagingIoAverageDataPoint(ts, float64(*dp.Value), AttributeDirectionReceive) } case "MAX_SWAP_IO_IN": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemPagingIoMaxDataPoint(ts, float64(*dp.Value), AttributeDirection.Receive) + mb.RecordMongodbatlasSystemPagingIoMaxDataPoint(ts, float64(*dp.Value), AttributeDirectionReceive) } case "SWAP_IO_OUT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemPagingIoAverageDataPoint(ts, float64(*dp.Value), AttributeDirection.Transmit) + mb.RecordMongodbatlasSystemPagingIoAverageDataPoint(ts, float64(*dp.Value), AttributeDirectionTransmit) } case "MAX_SWAP_IO_OUT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemPagingIoMaxDataPoint(ts, float64(*dp.Value), AttributeDirection.Transmit) + mb.RecordMongodbatlasSystemPagingIoMaxDataPoint(ts, float64(*dp.Value), AttributeDirectionTransmit) } // Memory usage, in bytes, that Atlas Search processes use. case "FTS_PROCESS_RESIDENT_MEMORY": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemFtsMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryState.Resident) + mb.RecordMongodbatlasSystemFtsMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryStateResident) } case "FTS_PROCESS_VIRTUAL_MEMORY": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemFtsMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryState.Virtual) + mb.RecordMongodbatlasSystemFtsMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryStateVirtual) } case "FTS_PROCESS_SHARED_MEMORY": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemFtsMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryState.Shared) + mb.RecordMongodbatlasSystemFtsMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryStateShared) } case "FTS_MEMORY_MAPPED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemFtsMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryState.Mapped) + mb.RecordMongodbatlasSystemFtsMemoryUsageDataPoint(ts, float64(*dp.Value), AttributeMemoryStateMapped) } // Disk space, in bytes, that Atlas Search indexes use. @@ -697,19 +697,19 @@ func getRecordFunc(metricName string) metricRecordFunc { // Percentage of CPU that Atlas Search processes use. case "FTS_PROCESS_CPU_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemFtsCPUUsageDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasSystemFtsCPUUsageDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "FTS_PROCESS_CPU_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemFtsCPUUsageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasSystemFtsCPUUsageDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } case "FTS_PROCESS_NORMALIZED_CPU_USER": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemFtsCPUNormalizedUsageDataPoint(ts, float64(*dp.Value), AttributeCPUState.User) + mb.RecordMongodbatlasSystemFtsCPUNormalizedUsageDataPoint(ts, float64(*dp.Value), AttributeCPUStateUser) } case "FTS_PROCESS_NORMALIZED_CPU_KERNEL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasSystemFtsCPUNormalizedUsageDataPoint(ts, float64(*dp.Value), AttributeCPUState.Kernel) + mb.RecordMongodbatlasSystemFtsCPUNormalizedUsageDataPoint(ts, float64(*dp.Value), AttributeCPUStateKernel) } // Process Disk Measurements (https://docs.atlas.mongodb.com/reference/api/process-disks-measurements/) @@ -717,130 +717,130 @@ func getRecordFunc(metricName string) metricRecordFunc { // Measures throughput of I/O operations for the disk partition used for MongoDB. case "DISK_PARTITION_IOPS_READ": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionIopsAverageDataPoint(ts, float64(*dp.Value), AttributeDiskDirection.Read) + mb.RecordMongodbatlasDiskPartitionIopsAverageDataPoint(ts, float64(*dp.Value), AttributeDiskDirectionRead) } case "MAX_DISK_PARTITION_IOPS_READ": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionIopsAverageDataPoint(ts, float64(*dp.Value), AttributeDiskDirection.Read) + mb.RecordMongodbatlasDiskPartitionIopsAverageDataPoint(ts, float64(*dp.Value), AttributeDiskDirectionRead) } case "DISK_PARTITION_IOPS_WRITE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionIopsAverageDataPoint(ts, float64(*dp.Value), AttributeDiskDirection.Write) + mb.RecordMongodbatlasDiskPartitionIopsAverageDataPoint(ts, float64(*dp.Value), AttributeDiskDirectionWrite) } case "MAX_DISK_PARTITION_IOPS_WRITE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionIopsMaxDataPoint(ts, float64(*dp.Value), AttributeDiskDirection.Write) + mb.RecordMongodbatlasDiskPartitionIopsMaxDataPoint(ts, float64(*dp.Value), AttributeDiskDirectionWrite) } case "DISK_PARTITION_IOPS_TOTAL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionIopsAverageDataPoint(ts, float64(*dp.Value), AttributeDiskDirection.Total) + mb.RecordMongodbatlasDiskPartitionIopsAverageDataPoint(ts, float64(*dp.Value), AttributeDiskDirectionTotal) } case "MAX_DISK_PARTITION_IOPS_TOTAL": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionIopsMaxDataPoint(ts, float64(*dp.Value), AttributeDiskDirection.Total) + mb.RecordMongodbatlasDiskPartitionIopsMaxDataPoint(ts, float64(*dp.Value), AttributeDiskDirectionTotal) } // The percentage of time during which requests are being issued to and serviced by the partition. // This includes requests from any process, not just MongoDB processes. case "DISK_PARTITION_LATENCY_READ": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionLatencyAverageDataPoint(ts, float64(*dp.Value), AttributeDiskDirection.Read) + mb.RecordMongodbatlasDiskPartitionLatencyAverageDataPoint(ts, float64(*dp.Value), AttributeDiskDirectionRead) } case "MAX_DISK_PARTITION_LATENCY_READ": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionLatencyMaxDataPoint(ts, float64(*dp.Value), AttributeDiskDirection.Read) + mb.RecordMongodbatlasDiskPartitionLatencyMaxDataPoint(ts, float64(*dp.Value), AttributeDiskDirectionRead) } case "DISK_PARTITION_LATENCY_WRITE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionLatencyAverageDataPoint(ts, float64(*dp.Value), AttributeDiskDirection.Write) + mb.RecordMongodbatlasDiskPartitionLatencyAverageDataPoint(ts, float64(*dp.Value), AttributeDiskDirectionWrite) } case "MAX_DISK_PARTITION_LATENCY_WRITE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionLatencyMaxDataPoint(ts, float64(*dp.Value), AttributeDiskDirection.Write) + mb.RecordMongodbatlasDiskPartitionLatencyMaxDataPoint(ts, float64(*dp.Value), AttributeDiskDirectionWrite) } // Measures latency per operation type of the disk partition used by MongoDB. case "DISK_PARTITION_SPACE_FREE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionSpaceAverageDataPoint(ts, float64(*dp.Value), AttributeDiskStatus.Free) + mb.RecordMongodbatlasDiskPartitionSpaceAverageDataPoint(ts, float64(*dp.Value), AttributeDiskStatusFree) } case "MAX_DISK_PARTITION_SPACE_FREE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionSpaceMaxDataPoint(ts, float64(*dp.Value), AttributeDiskStatus.Free) + mb.RecordMongodbatlasDiskPartitionSpaceMaxDataPoint(ts, float64(*dp.Value), AttributeDiskStatusFree) } case "DISK_PARTITION_SPACE_USED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionSpaceAverageDataPoint(ts, float64(*dp.Value), AttributeDiskStatus.Used) + mb.RecordMongodbatlasDiskPartitionSpaceAverageDataPoint(ts, float64(*dp.Value), AttributeDiskStatusUsed) } case "MAX_DISK_PARTITION_SPACE_USED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionSpaceMaxDataPoint(ts, float64(*dp.Value), AttributeDiskStatus.Used) + mb.RecordMongodbatlasDiskPartitionSpaceMaxDataPoint(ts, float64(*dp.Value), AttributeDiskStatusUsed) } case "DISK_PARTITION_SPACE_PERCENT_FREE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionUtilizationAverageDataPoint(ts, float64(*dp.Value), AttributeDiskStatus.Free) + mb.RecordMongodbatlasDiskPartitionUtilizationAverageDataPoint(ts, float64(*dp.Value), AttributeDiskStatusFree) } case "MAX_DISK_PARTITION_SPACE_PERCENT_FREE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionUtilizationMaxDataPoint(ts, float64(*dp.Value), AttributeDiskStatus.Free) + mb.RecordMongodbatlasDiskPartitionUtilizationMaxDataPoint(ts, float64(*dp.Value), AttributeDiskStatusFree) } case "DISK_PARTITION_SPACE_PERCENT_USED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionUtilizationAverageDataPoint(ts, float64(*dp.Value), AttributeDiskStatus.Used) + mb.RecordMongodbatlasDiskPartitionUtilizationAverageDataPoint(ts, float64(*dp.Value), AttributeDiskStatusUsed) } case "MAX_DISK_PARTITION_SPACE_PERCENT_USED": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDiskPartitionUtilizationMaxDataPoint(ts, float64(*dp.Value), AttributeDiskStatus.Used) + mb.RecordMongodbatlasDiskPartitionUtilizationMaxDataPoint(ts, float64(*dp.Value), AttributeDiskStatusUsed) } // Process Database Measurements (https://docs.atlas.mongodb.com/reference/api/process-disks-measurements/) case "DATABASE_COLLECTION_COUNT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDbCountsDataPoint(ts, float64(*dp.Value), AttributeObjectType.Collection) + mb.RecordMongodbatlasDbCountsDataPoint(ts, float64(*dp.Value), AttributeObjectTypeCollection) } case "DATABASE_INDEX_COUNT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDbCountsDataPoint(ts, float64(*dp.Value), AttributeObjectType.Index) + mb.RecordMongodbatlasDbCountsDataPoint(ts, float64(*dp.Value), AttributeObjectTypeIndex) } case "DATABASE_EXTENT_COUNT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDbCountsDataPoint(ts, float64(*dp.Value), AttributeObjectType.Extent) + mb.RecordMongodbatlasDbCountsDataPoint(ts, float64(*dp.Value), AttributeObjectTypeExtent) } case "DATABASE_OBJECT_COUNT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDbCountsDataPoint(ts, float64(*dp.Value), AttributeObjectType.Object) + mb.RecordMongodbatlasDbCountsDataPoint(ts, float64(*dp.Value), AttributeObjectTypeObject) } case "DATABASE_VIEW_COUNT": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDbCountsDataPoint(ts, float64(*dp.Value), AttributeObjectType.View) + mb.RecordMongodbatlasDbCountsDataPoint(ts, float64(*dp.Value), AttributeObjectTypeView) } case "DATABASE_AVERAGE_OBJECT_SIZE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDbSizeDataPoint(ts, float64(*dp.Value), AttributeObjectType.Object) + mb.RecordMongodbatlasDbSizeDataPoint(ts, float64(*dp.Value), AttributeObjectTypeObject) } case "DATABASE_STORAGE_SIZE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDbSizeDataPoint(ts, float64(*dp.Value), AttributeObjectType.Storage) + mb.RecordMongodbatlasDbSizeDataPoint(ts, float64(*dp.Value), AttributeObjectTypeStorage) } case "DATABASE_INDEX_SIZE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDbSizeDataPoint(ts, float64(*dp.Value), AttributeObjectType.Index) + mb.RecordMongodbatlasDbSizeDataPoint(ts, float64(*dp.Value), AttributeObjectTypeIndex) } case "DATABASE_DATA_SIZE": return func(mb *MetricsBuilder, dp *mongodbatlas.DataPoints, ts pcommon.Timestamp) { - mb.RecordMongodbatlasDbSizeDataPoint(ts, float64(*dp.Value), AttributeObjectType.Data) + mb.RecordMongodbatlasDbSizeDataPoint(ts, float64(*dp.Value), AttributeObjectTypeData) } default: diff --git a/receiver/mongodbatlasreceiver/metadata.yaml b/receiver/mongodbatlasreceiver/metadata.yaml index 8a03e605aed9..280d41252caa 100644 --- a/receiver/mongodbatlasreceiver/metadata.yaml +++ b/receiver/mongodbatlasreceiver/metadata.yaml @@ -454,7 +454,7 @@ metrics: description: Swap usage extended_documentation: Aggregate of MongoDB Metrics MAX_SWAP_USAGE_FREE, MAX_SWAP_USAGE_USED unit: KiBy - attributes: [direction] + attributes: [memory_state] gauge: value_type: double mongodbatlas.system.paging.usage.average: @@ -462,7 +462,7 @@ metrics: description: Swap usage extended_documentation: Aggregate of MongoDB Metrics SWAP_USAGE_FREE, SWAP_USAGE_USED unit: KiBy - attributes: [direction] + attributes: [memory_state] gauge: value_type: double mongodbatlas.system.paging.io.max: diff --git a/receiver/mongodbreceiver/internal/metadata/generated_metrics_v2.go b/receiver/mongodbreceiver/internal/metadata/generated_metrics_v2.go index e411c73232a5..944d0a16e4f2 100644 --- a/receiver/mongodbreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/mongodbreceiver/internal/metadata/generated_metrics_v2.go @@ -71,6 +71,130 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeConnectionType specifies the a value connection_type attribute. +type AttributeConnectionType int + +const ( + _ AttributeConnectionType = iota + AttributeConnectionTypeActive + AttributeConnectionTypeAvailable + AttributeConnectionTypeCurrent +) + +// String returns the string representation of the AttributeConnectionType. +func (av AttributeConnectionType) String() string { + switch av { + case AttributeConnectionTypeActive: + return "active" + case AttributeConnectionTypeAvailable: + return "available" + case AttributeConnectionTypeCurrent: + return "current" + } + return "" +} + +// MapAttributeConnectionType is a helper map of string to AttributeConnectionType attribute value. +var MapAttributeConnectionType = map[string]AttributeConnectionType{ + "active": AttributeConnectionTypeActive, + "available": AttributeConnectionTypeAvailable, + "current": AttributeConnectionTypeCurrent, +} + +// AttributeMemoryType specifies the a value memory_type attribute. +type AttributeMemoryType int + +const ( + _ AttributeMemoryType = iota + AttributeMemoryTypeResident + AttributeMemoryTypeVirtual +) + +// String returns the string representation of the AttributeMemoryType. +func (av AttributeMemoryType) String() string { + switch av { + case AttributeMemoryTypeResident: + return "resident" + case AttributeMemoryTypeVirtual: + return "virtual" + } + return "" +} + +// MapAttributeMemoryType is a helper map of string to AttributeMemoryType attribute value. +var MapAttributeMemoryType = map[string]AttributeMemoryType{ + "resident": AttributeMemoryTypeResident, + "virtual": AttributeMemoryTypeVirtual, +} + +// AttributeOperation specifies the a value operation attribute. +type AttributeOperation int + +const ( + _ AttributeOperation = iota + AttributeOperationInsert + AttributeOperationQuery + AttributeOperationUpdate + AttributeOperationDelete + AttributeOperationGetmore + AttributeOperationCommand +) + +// String returns the string representation of the AttributeOperation. +func (av AttributeOperation) String() string { + switch av { + case AttributeOperationInsert: + return "insert" + case AttributeOperationQuery: + return "query" + case AttributeOperationUpdate: + return "update" + case AttributeOperationDelete: + return "delete" + case AttributeOperationGetmore: + return "getmore" + case AttributeOperationCommand: + return "command" + } + return "" +} + +// MapAttributeOperation is a helper map of string to AttributeOperation attribute value. +var MapAttributeOperation = map[string]AttributeOperation{ + "insert": AttributeOperationInsert, + "query": AttributeOperationQuery, + "update": AttributeOperationUpdate, + "delete": AttributeOperationDelete, + "getmore": AttributeOperationGetmore, + "command": AttributeOperationCommand, +} + +// AttributeType specifies the a value type attribute. +type AttributeType int + +const ( + _ AttributeType = iota + AttributeTypeHit + AttributeTypeMiss +) + +// String returns the string representation of the AttributeType. +func (av AttributeType) String() string { + switch av { + case AttributeTypeHit: + return "hit" + case AttributeTypeMiss: + return "miss" + } + return "" +} + +// MapAttributeType is a helper map of string to AttributeType attribute value. +var MapAttributeType = map[string]AttributeType{ + "hit": AttributeTypeHit, + "miss": AttributeTypeMiss, +} + type metricMongodbCacheOperations struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -816,8 +940,8 @@ func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pmetric.Metrics { } // RecordMongodbCacheOperationsDataPoint adds a data point to mongodb.cache.operations metric. -func (mb *MetricsBuilder) RecordMongodbCacheOperationsDataPoint(ts pcommon.Timestamp, val int64, typeAttributeValue string) { - mb.metricMongodbCacheOperations.recordDataPoint(mb.startTime, ts, val, typeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbCacheOperationsDataPoint(ts pcommon.Timestamp, val int64, typeAttributeValue AttributeType) { + mb.metricMongodbCacheOperations.recordDataPoint(mb.startTime, ts, val, typeAttributeValue.String()) } // RecordMongodbCollectionCountDataPoint adds a data point to mongodb.collection.count metric. @@ -826,8 +950,8 @@ func (mb *MetricsBuilder) RecordMongodbCollectionCountDataPoint(ts pcommon.Times } // RecordMongodbConnectionCountDataPoint adds a data point to mongodb.connection.count metric. -func (mb *MetricsBuilder) RecordMongodbConnectionCountDataPoint(ts pcommon.Timestamp, val int64, databaseAttributeValue string, connectionTypeAttributeValue string) { - mb.metricMongodbConnectionCount.recordDataPoint(mb.startTime, ts, val, databaseAttributeValue, connectionTypeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbConnectionCountDataPoint(ts pcommon.Timestamp, val int64, databaseAttributeValue string, connectionTypeAttributeValue AttributeConnectionType) { + mb.metricMongodbConnectionCount.recordDataPoint(mb.startTime, ts, val, databaseAttributeValue, connectionTypeAttributeValue.String()) } // RecordMongodbDataSizeDataPoint adds a data point to mongodb.data.size metric. @@ -856,8 +980,8 @@ func (mb *MetricsBuilder) RecordMongodbIndexSizeDataPoint(ts pcommon.Timestamp, } // RecordMongodbMemoryUsageDataPoint adds a data point to mongodb.memory.usage metric. -func (mb *MetricsBuilder) RecordMongodbMemoryUsageDataPoint(ts pcommon.Timestamp, val int64, databaseAttributeValue string, memoryTypeAttributeValue string) { - mb.metricMongodbMemoryUsage.recordDataPoint(mb.startTime, ts, val, databaseAttributeValue, memoryTypeAttributeValue) +func (mb *MetricsBuilder) RecordMongodbMemoryUsageDataPoint(ts pcommon.Timestamp, val int64, databaseAttributeValue string, memoryTypeAttributeValue AttributeMemoryType) { + mb.metricMongodbMemoryUsage.recordDataPoint(mb.startTime, ts, val, databaseAttributeValue, memoryTypeAttributeValue.String()) } // RecordMongodbObjectCountDataPoint adds a data point to mongodb.object.count metric. @@ -866,8 +990,8 @@ func (mb *MetricsBuilder) RecordMongodbObjectCountDataPoint(ts pcommon.Timestamp } // RecordMongodbOperationCountDataPoint adds a data point to mongodb.operation.count metric. -func (mb *MetricsBuilder) RecordMongodbOperationCountDataPoint(ts pcommon.Timestamp, val int64, operationAttributeValue string) { - mb.metricMongodbOperationCount.recordDataPoint(mb.startTime, ts, val, operationAttributeValue) +func (mb *MetricsBuilder) RecordMongodbOperationCountDataPoint(ts pcommon.Timestamp, val int64, operationAttributeValue AttributeOperation) { + mb.metricMongodbOperationCount.recordDataPoint(mb.startTime, ts, val, operationAttributeValue.String()) } // RecordMongodbStorageSizeDataPoint adds a data point to mongodb.storage.size metric. @@ -906,49 +1030,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeConnectionType are the possible values that the attribute "connection_type" can have. -var AttributeConnectionType = struct { - Active string - Available string - Current string -}{ - "active", - "available", - "current", -} - -// AttributeMemoryType are the possible values that the attribute "memory_type" can have. -var AttributeMemoryType = struct { - Resident string - Virtual string -}{ - "resident", - "virtual", -} - -// AttributeOperation are the possible values that the attribute "operation" can have. -var AttributeOperation = struct { - Insert string - Query string - Update string - Delete string - Getmore string - Command string -}{ - "insert", - "query", - "update", - "delete", - "getmore", - "command", -} - -// AttributeType are the possible values that the attribute "type" can have. -var AttributeType = struct { - Hit string - Miss string -}{ - "hit", - "miss", -} diff --git a/receiver/mongodbreceiver/metrics.go b/receiver/mongodbreceiver/metrics.go index 519bac193666..06f1f96f0221 100644 --- a/receiver/mongodbreceiver/metrics.go +++ b/receiver/mongodbreceiver/metrics.go @@ -136,13 +136,8 @@ func (s *mongodbScraper) recordExtentCount(now pcommon.Timestamp, doc bson.M, db // ServerStatus func (s *mongodbScraper) recordConnections(now pcommon.Timestamp, doc bson.M, dbName string, errors scrapererror.ScrapeErrors) { - types := []string{ - metadata.AttributeConnectionType.Active, - metadata.AttributeConnectionType.Available, - metadata.AttributeConnectionType.Current, - } - for _, ct := range types { - connKey := []string{"connections", ct} + for ctVal, ct := range metadata.MapAttributeConnectionType { + connKey := []string{"connections", ctVal} conn, err := dig(doc, connKey) if err != nil { errors.AddPartial(1, err) @@ -159,12 +154,8 @@ func (s *mongodbScraper) recordConnections(now pcommon.Timestamp, doc bson.M, db } func (s *mongodbScraper) recordMemoryUsage(now pcommon.Timestamp, doc bson.M, dbName string, errors scrapererror.ScrapeErrors) { - types := []string{ - metadata.AttributeMemoryType.Resident, - metadata.AttributeMemoryType.Virtual, - } - for _, mt := range types { - memKey := []string{"mem", mt} + for mtVal, mt := range metadata.MapAttributeMemoryType { + memKey := []string{"mem", mtVal} mem, err := dig(doc, memKey) if err != nil { errors.AddPartial(1, err) @@ -185,18 +176,11 @@ func (s *mongodbScraper) recordMemoryUsage(now pcommon.Timestamp, doc bson.M, db // Admin Stats func (s *mongodbScraper) recordOperations(now pcommon.Timestamp, doc bson.M, errors scrapererror.ScrapeErrors) { // Collect Operations - for _, operation := range []string{ - metadata.AttributeOperation.Insert, - metadata.AttributeOperation.Query, - metadata.AttributeOperation.Update, - metadata.AttributeOperation.Delete, - metadata.AttributeOperation.Getmore, - metadata.AttributeOperation.Command, - } { - count, err := dig(doc, []string{"opcounters", operation}) + for operationVal, operation := range metadata.MapAttributeOperation { + count, err := dig(doc, []string{"opcounters", operationVal}) if err != nil { errors.AddPartial(1, err) - s.logger.Error("failed to find operation", zap.Error(err), zap.String("operation", operation)) + s.logger.Error("failed to find operation", zap.Error(err), zap.String("operation", operationVal)) continue } countVal, err := parseInt(count) @@ -224,7 +208,7 @@ func (s *mongodbScraper) recordCacheOperations(now pcommon.Timestamp, doc bson.M if err != nil { errors.AddPartial(1, err) } else { - s.mb.RecordMongodbCacheOperationsDataPoint(now, cacheMissesValue, metadata.AttributeType.Miss) + s.mb.RecordMongodbCacheOperationsDataPoint(now, cacheMissesValue, metadata.AttributeTypeMiss) } tcr, err := dig(doc, []string{"wiredTiger", "cache", "pages requested from the cache"}) @@ -242,7 +226,7 @@ func (s *mongodbScraper) recordCacheOperations(now pcommon.Timestamp, doc bson.M if canCalculateCacheHits && totalCacheReqs > cacheMissesValue { cacheHits := totalCacheReqs - cacheMissesValue - s.mb.RecordMongodbCacheOperationsDataPoint(now, cacheHits, metadata.AttributeType.Hit) + s.mb.RecordMongodbCacheOperationsDataPoint(now, cacheHits, metadata.AttributeTypeHit) } } diff --git a/receiver/mysqlreceiver/internal/metadata/generated_metrics_v2.go b/receiver/mysqlreceiver/internal/metadata/generated_metrics_v2.go index deb3570ae2d3..9cd7aa1b19e1 100644 --- a/receiver/mysqlreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/mysqlreceiver/internal/metadata/generated_metrics_v2.go @@ -93,6 +93,510 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeBufferPoolData specifies the a value buffer_pool_data attribute. +type AttributeBufferPoolData int + +const ( + _ AttributeBufferPoolData = iota + AttributeBufferPoolDataDirty + AttributeBufferPoolDataClean +) + +// String returns the string representation of the AttributeBufferPoolData. +func (av AttributeBufferPoolData) String() string { + switch av { + case AttributeBufferPoolDataDirty: + return "dirty" + case AttributeBufferPoolDataClean: + return "clean" + } + return "" +} + +// MapAttributeBufferPoolData is a helper map of string to AttributeBufferPoolData attribute value. +var MapAttributeBufferPoolData = map[string]AttributeBufferPoolData{ + "dirty": AttributeBufferPoolDataDirty, + "clean": AttributeBufferPoolDataClean, +} + +// AttributeBufferPoolOperations specifies the a value buffer_pool_operations attribute. +type AttributeBufferPoolOperations int + +const ( + _ AttributeBufferPoolOperations = iota + AttributeBufferPoolOperationsReadAheadRnd + AttributeBufferPoolOperationsReadAhead + AttributeBufferPoolOperationsReadAheadEvicted + AttributeBufferPoolOperationsReadRequests + AttributeBufferPoolOperationsReads + AttributeBufferPoolOperationsWaitFree + AttributeBufferPoolOperationsWriteRequests +) + +// String returns the string representation of the AttributeBufferPoolOperations. +func (av AttributeBufferPoolOperations) String() string { + switch av { + case AttributeBufferPoolOperationsReadAheadRnd: + return "read_ahead_rnd" + case AttributeBufferPoolOperationsReadAhead: + return "read_ahead" + case AttributeBufferPoolOperationsReadAheadEvicted: + return "read_ahead_evicted" + case AttributeBufferPoolOperationsReadRequests: + return "read_requests" + case AttributeBufferPoolOperationsReads: + return "reads" + case AttributeBufferPoolOperationsWaitFree: + return "wait_free" + case AttributeBufferPoolOperationsWriteRequests: + return "write_requests" + } + return "" +} + +// MapAttributeBufferPoolOperations is a helper map of string to AttributeBufferPoolOperations attribute value. +var MapAttributeBufferPoolOperations = map[string]AttributeBufferPoolOperations{ + "read_ahead_rnd": AttributeBufferPoolOperationsReadAheadRnd, + "read_ahead": AttributeBufferPoolOperationsReadAhead, + "read_ahead_evicted": AttributeBufferPoolOperationsReadAheadEvicted, + "read_requests": AttributeBufferPoolOperationsReadRequests, + "reads": AttributeBufferPoolOperationsReads, + "wait_free": AttributeBufferPoolOperationsWaitFree, + "write_requests": AttributeBufferPoolOperationsWriteRequests, +} + +// AttributeBufferPoolPages specifies the a value buffer_pool_pages attribute. +type AttributeBufferPoolPages int + +const ( + _ AttributeBufferPoolPages = iota + AttributeBufferPoolPagesData + AttributeBufferPoolPagesFree + AttributeBufferPoolPagesMisc +) + +// String returns the string representation of the AttributeBufferPoolPages. +func (av AttributeBufferPoolPages) String() string { + switch av { + case AttributeBufferPoolPagesData: + return "data" + case AttributeBufferPoolPagesFree: + return "free" + case AttributeBufferPoolPagesMisc: + return "misc" + } + return "" +} + +// MapAttributeBufferPoolPages is a helper map of string to AttributeBufferPoolPages attribute value. +var MapAttributeBufferPoolPages = map[string]AttributeBufferPoolPages{ + "data": AttributeBufferPoolPagesData, + "free": AttributeBufferPoolPagesFree, + "misc": AttributeBufferPoolPagesMisc, +} + +// AttributeCommand specifies the a value command attribute. +type AttributeCommand int + +const ( + _ AttributeCommand = iota + AttributeCommandExecute + AttributeCommandClose + AttributeCommandFetch + AttributeCommandPrepare + AttributeCommandReset + AttributeCommandSendLongData +) + +// String returns the string representation of the AttributeCommand. +func (av AttributeCommand) String() string { + switch av { + case AttributeCommandExecute: + return "execute" + case AttributeCommandClose: + return "close" + case AttributeCommandFetch: + return "fetch" + case AttributeCommandPrepare: + return "prepare" + case AttributeCommandReset: + return "reset" + case AttributeCommandSendLongData: + return "send_long_data" + } + return "" +} + +// MapAttributeCommand is a helper map of string to AttributeCommand attribute value. +var MapAttributeCommand = map[string]AttributeCommand{ + "execute": AttributeCommandExecute, + "close": AttributeCommandClose, + "fetch": AttributeCommandFetch, + "prepare": AttributeCommandPrepare, + "reset": AttributeCommandReset, + "send_long_data": AttributeCommandSendLongData, +} + +// AttributeDoubleWrites specifies the a value double_writes attribute. +type AttributeDoubleWrites int + +const ( + _ AttributeDoubleWrites = iota + AttributeDoubleWritesPagesWritten + AttributeDoubleWritesWrites +) + +// String returns the string representation of the AttributeDoubleWrites. +func (av AttributeDoubleWrites) String() string { + switch av { + case AttributeDoubleWritesPagesWritten: + return "pages_written" + case AttributeDoubleWritesWrites: + return "writes" + } + return "" +} + +// MapAttributeDoubleWrites is a helper map of string to AttributeDoubleWrites attribute value. +var MapAttributeDoubleWrites = map[string]AttributeDoubleWrites{ + "pages_written": AttributeDoubleWritesPagesWritten, + "writes": AttributeDoubleWritesWrites, +} + +// AttributeHandler specifies the a value handler attribute. +type AttributeHandler int + +const ( + _ AttributeHandler = iota + AttributeHandlerCommit + AttributeHandlerDelete + AttributeHandlerDiscover + AttributeHandlerExternalLock + AttributeHandlerMrrInit + AttributeHandlerPrepare + AttributeHandlerReadFirst + AttributeHandlerReadKey + AttributeHandlerReadLast + AttributeHandlerReadNext + AttributeHandlerReadPrev + AttributeHandlerReadRnd + AttributeHandlerReadRndNext + AttributeHandlerRollback + AttributeHandlerSavepoint + AttributeHandlerSavepointRollback + AttributeHandlerUpdate + AttributeHandlerWrite +) + +// String returns the string representation of the AttributeHandler. +func (av AttributeHandler) String() string { + switch av { + case AttributeHandlerCommit: + return "commit" + case AttributeHandlerDelete: + return "delete" + case AttributeHandlerDiscover: + return "discover" + case AttributeHandlerExternalLock: + return "external_lock" + case AttributeHandlerMrrInit: + return "mrr_init" + case AttributeHandlerPrepare: + return "prepare" + case AttributeHandlerReadFirst: + return "read_first" + case AttributeHandlerReadKey: + return "read_key" + case AttributeHandlerReadLast: + return "read_last" + case AttributeHandlerReadNext: + return "read_next" + case AttributeHandlerReadPrev: + return "read_prev" + case AttributeHandlerReadRnd: + return "read_rnd" + case AttributeHandlerReadRndNext: + return "read_rnd_next" + case AttributeHandlerRollback: + return "rollback" + case AttributeHandlerSavepoint: + return "savepoint" + case AttributeHandlerSavepointRollback: + return "savepoint_rollback" + case AttributeHandlerUpdate: + return "update" + case AttributeHandlerWrite: + return "write" + } + return "" +} + +// MapAttributeHandler is a helper map of string to AttributeHandler attribute value. +var MapAttributeHandler = map[string]AttributeHandler{ + "commit": AttributeHandlerCommit, + "delete": AttributeHandlerDelete, + "discover": AttributeHandlerDiscover, + "external_lock": AttributeHandlerExternalLock, + "mrr_init": AttributeHandlerMrrInit, + "prepare": AttributeHandlerPrepare, + "read_first": AttributeHandlerReadFirst, + "read_key": AttributeHandlerReadKey, + "read_last": AttributeHandlerReadLast, + "read_next": AttributeHandlerReadNext, + "read_prev": AttributeHandlerReadPrev, + "read_rnd": AttributeHandlerReadRnd, + "read_rnd_next": AttributeHandlerReadRndNext, + "rollback": AttributeHandlerRollback, + "savepoint": AttributeHandlerSavepoint, + "savepoint_rollback": AttributeHandlerSavepointRollback, + "update": AttributeHandlerUpdate, + "write": AttributeHandlerWrite, +} + +// AttributeLocks specifies the a value locks attribute. +type AttributeLocks int + +const ( + _ AttributeLocks = iota + AttributeLocksImmediate + AttributeLocksWaited +) + +// String returns the string representation of the AttributeLocks. +func (av AttributeLocks) String() string { + switch av { + case AttributeLocksImmediate: + return "immediate" + case AttributeLocksWaited: + return "waited" + } + return "" +} + +// MapAttributeLocks is a helper map of string to AttributeLocks attribute value. +var MapAttributeLocks = map[string]AttributeLocks{ + "immediate": AttributeLocksImmediate, + "waited": AttributeLocksWaited, +} + +// AttributeLogOperations specifies the a value log_operations attribute. +type AttributeLogOperations int + +const ( + _ AttributeLogOperations = iota + AttributeLogOperationsWaits + AttributeLogOperationsWriteRequests + AttributeLogOperationsWrites +) + +// String returns the string representation of the AttributeLogOperations. +func (av AttributeLogOperations) String() string { + switch av { + case AttributeLogOperationsWaits: + return "waits" + case AttributeLogOperationsWriteRequests: + return "write_requests" + case AttributeLogOperationsWrites: + return "writes" + } + return "" +} + +// MapAttributeLogOperations is a helper map of string to AttributeLogOperations attribute value. +var MapAttributeLogOperations = map[string]AttributeLogOperations{ + "waits": AttributeLogOperationsWaits, + "write_requests": AttributeLogOperationsWriteRequests, + "writes": AttributeLogOperationsWrites, +} + +// AttributeOperations specifies the a value operations attribute. +type AttributeOperations int + +const ( + _ AttributeOperations = iota + AttributeOperationsFsyncs + AttributeOperationsReads + AttributeOperationsWrites +) + +// String returns the string representation of the AttributeOperations. +func (av AttributeOperations) String() string { + switch av { + case AttributeOperationsFsyncs: + return "fsyncs" + case AttributeOperationsReads: + return "reads" + case AttributeOperationsWrites: + return "writes" + } + return "" +} + +// MapAttributeOperations is a helper map of string to AttributeOperations attribute value. +var MapAttributeOperations = map[string]AttributeOperations{ + "fsyncs": AttributeOperationsFsyncs, + "reads": AttributeOperationsReads, + "writes": AttributeOperationsWrites, +} + +// AttributePageOperations specifies the a value page_operations attribute. +type AttributePageOperations int + +const ( + _ AttributePageOperations = iota + AttributePageOperationsCreated + AttributePageOperationsRead + AttributePageOperationsWritten +) + +// String returns the string representation of the AttributePageOperations. +func (av AttributePageOperations) String() string { + switch av { + case AttributePageOperationsCreated: + return "created" + case AttributePageOperationsRead: + return "read" + case AttributePageOperationsWritten: + return "written" + } + return "" +} + +// MapAttributePageOperations is a helper map of string to AttributePageOperations attribute value. +var MapAttributePageOperations = map[string]AttributePageOperations{ + "created": AttributePageOperationsCreated, + "read": AttributePageOperationsRead, + "written": AttributePageOperationsWritten, +} + +// AttributeRowLocks specifies the a value row_locks attribute. +type AttributeRowLocks int + +const ( + _ AttributeRowLocks = iota + AttributeRowLocksWaits + AttributeRowLocksTime +) + +// String returns the string representation of the AttributeRowLocks. +func (av AttributeRowLocks) String() string { + switch av { + case AttributeRowLocksWaits: + return "waits" + case AttributeRowLocksTime: + return "time" + } + return "" +} + +// MapAttributeRowLocks is a helper map of string to AttributeRowLocks attribute value. +var MapAttributeRowLocks = map[string]AttributeRowLocks{ + "waits": AttributeRowLocksWaits, + "time": AttributeRowLocksTime, +} + +// AttributeRowOperations specifies the a value row_operations attribute. +type AttributeRowOperations int + +const ( + _ AttributeRowOperations = iota + AttributeRowOperationsDeleted + AttributeRowOperationsInserted + AttributeRowOperationsRead + AttributeRowOperationsUpdated +) + +// String returns the string representation of the AttributeRowOperations. +func (av AttributeRowOperations) String() string { + switch av { + case AttributeRowOperationsDeleted: + return "deleted" + case AttributeRowOperationsInserted: + return "inserted" + case AttributeRowOperationsRead: + return "read" + case AttributeRowOperationsUpdated: + return "updated" + } + return "" +} + +// MapAttributeRowOperations is a helper map of string to AttributeRowOperations attribute value. +var MapAttributeRowOperations = map[string]AttributeRowOperations{ + "deleted": AttributeRowOperationsDeleted, + "inserted": AttributeRowOperationsInserted, + "read": AttributeRowOperationsRead, + "updated": AttributeRowOperationsUpdated, +} + +// AttributeSorts specifies the a value sorts attribute. +type AttributeSorts int + +const ( + _ AttributeSorts = iota + AttributeSortsMergePasses + AttributeSortsRange + AttributeSortsRows + AttributeSortsScan +) + +// String returns the string representation of the AttributeSorts. +func (av AttributeSorts) String() string { + switch av { + case AttributeSortsMergePasses: + return "merge_passes" + case AttributeSortsRange: + return "range" + case AttributeSortsRows: + return "rows" + case AttributeSortsScan: + return "scan" + } + return "" +} + +// MapAttributeSorts is a helper map of string to AttributeSorts attribute value. +var MapAttributeSorts = map[string]AttributeSorts{ + "merge_passes": AttributeSortsMergePasses, + "range": AttributeSortsRange, + "rows": AttributeSortsRows, + "scan": AttributeSortsScan, +} + +// AttributeThreads specifies the a value threads attribute. +type AttributeThreads int + +const ( + _ AttributeThreads = iota + AttributeThreadsCached + AttributeThreadsConnected + AttributeThreadsCreated + AttributeThreadsRunning +) + +// String returns the string representation of the AttributeThreads. +func (av AttributeThreads) String() string { + switch av { + case AttributeThreadsCached: + return "cached" + case AttributeThreadsConnected: + return "connected" + case AttributeThreadsCreated: + return "created" + case AttributeThreadsRunning: + return "running" + } + return "" +} + +// MapAttributeThreads is a helper map of string to AttributeThreads attribute value. +var MapAttributeThreads = map[string]AttributeThreads{ + "cached": AttributeThreadsCached, + "connected": AttributeThreadsConnected, + "created": AttributeThreadsCreated, + "running": AttributeThreadsRunning, +} + type metricMysqlBufferPoolDataPages struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -1114,8 +1618,8 @@ func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pmetric.Metrics { } // RecordMysqlBufferPoolDataPagesDataPoint adds a data point to mysql.buffer_pool.data_pages metric. -func (mb *MetricsBuilder) RecordMysqlBufferPoolDataPagesDataPoint(ts pcommon.Timestamp, val int64, bufferPoolDataAttributeValue string) { - mb.metricMysqlBufferPoolDataPages.recordDataPoint(mb.startTime, ts, val, bufferPoolDataAttributeValue) +func (mb *MetricsBuilder) RecordMysqlBufferPoolDataPagesDataPoint(ts pcommon.Timestamp, val int64, bufferPoolDataAttributeValue AttributeBufferPoolData) { + mb.metricMysqlBufferPoolDataPages.recordDataPoint(mb.startTime, ts, val, bufferPoolDataAttributeValue.String()) } // RecordMysqlBufferPoolLimitDataPoint adds a data point to mysql.buffer_pool.limit metric. @@ -1129,11 +1633,11 @@ func (mb *MetricsBuilder) RecordMysqlBufferPoolLimitDataPoint(ts pcommon.Timesta } // RecordMysqlBufferPoolOperationsDataPoint adds a data point to mysql.buffer_pool.operations metric. -func (mb *MetricsBuilder) RecordMysqlBufferPoolOperationsDataPoint(ts pcommon.Timestamp, val string, bufferPoolOperationsAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlBufferPoolOperationsDataPoint(ts pcommon.Timestamp, val string, bufferPoolOperationsAttributeValue AttributeBufferPoolOperations) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlBufferPoolOperations, value was %s: %w", val, err) } else { - mb.metricMysqlBufferPoolOperations.recordDataPoint(mb.startTime, ts, i, bufferPoolOperationsAttributeValue) + mb.metricMysqlBufferPoolOperations.recordDataPoint(mb.startTime, ts, i, bufferPoolOperationsAttributeValue.String()) } return nil } @@ -1149,126 +1653,126 @@ func (mb *MetricsBuilder) RecordMysqlBufferPoolPageFlushesDataPoint(ts pcommon.T } // RecordMysqlBufferPoolPagesDataPoint adds a data point to mysql.buffer_pool.pages metric. -func (mb *MetricsBuilder) RecordMysqlBufferPoolPagesDataPoint(ts pcommon.Timestamp, val string, bufferPoolPagesAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlBufferPoolPagesDataPoint(ts pcommon.Timestamp, val string, bufferPoolPagesAttributeValue AttributeBufferPoolPages) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlBufferPoolPages, value was %s: %w", val, err) } else { - mb.metricMysqlBufferPoolPages.recordDataPoint(mb.startTime, ts, i, bufferPoolPagesAttributeValue) + mb.metricMysqlBufferPoolPages.recordDataPoint(mb.startTime, ts, i, bufferPoolPagesAttributeValue.String()) } return nil } // RecordMysqlBufferPoolUsageDataPoint adds a data point to mysql.buffer_pool.usage metric. -func (mb *MetricsBuilder) RecordMysqlBufferPoolUsageDataPoint(ts pcommon.Timestamp, val int64, bufferPoolDataAttributeValue string) { - mb.metricMysqlBufferPoolUsage.recordDataPoint(mb.startTime, ts, val, bufferPoolDataAttributeValue) +func (mb *MetricsBuilder) RecordMysqlBufferPoolUsageDataPoint(ts pcommon.Timestamp, val int64, bufferPoolDataAttributeValue AttributeBufferPoolData) { + mb.metricMysqlBufferPoolUsage.recordDataPoint(mb.startTime, ts, val, bufferPoolDataAttributeValue.String()) } // RecordMysqlCommandsDataPoint adds a data point to mysql.commands metric. -func (mb *MetricsBuilder) RecordMysqlCommandsDataPoint(ts pcommon.Timestamp, val string, commandAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlCommandsDataPoint(ts pcommon.Timestamp, val string, commandAttributeValue AttributeCommand) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlCommands, value was %s: %w", val, err) } else { - mb.metricMysqlCommands.recordDataPoint(mb.startTime, ts, i, commandAttributeValue) + mb.metricMysqlCommands.recordDataPoint(mb.startTime, ts, i, commandAttributeValue.String()) } return nil } // RecordMysqlDoubleWritesDataPoint adds a data point to mysql.double_writes metric. -func (mb *MetricsBuilder) RecordMysqlDoubleWritesDataPoint(ts pcommon.Timestamp, val string, doubleWritesAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlDoubleWritesDataPoint(ts pcommon.Timestamp, val string, doubleWritesAttributeValue AttributeDoubleWrites) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlDoubleWrites, value was %s: %w", val, err) } else { - mb.metricMysqlDoubleWrites.recordDataPoint(mb.startTime, ts, i, doubleWritesAttributeValue) + mb.metricMysqlDoubleWrites.recordDataPoint(mb.startTime, ts, i, doubleWritesAttributeValue.String()) } return nil } // RecordMysqlHandlersDataPoint adds a data point to mysql.handlers metric. -func (mb *MetricsBuilder) RecordMysqlHandlersDataPoint(ts pcommon.Timestamp, val string, handlerAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlHandlersDataPoint(ts pcommon.Timestamp, val string, handlerAttributeValue AttributeHandler) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlHandlers, value was %s: %w", val, err) } else { - mb.metricMysqlHandlers.recordDataPoint(mb.startTime, ts, i, handlerAttributeValue) + mb.metricMysqlHandlers.recordDataPoint(mb.startTime, ts, i, handlerAttributeValue.String()) } return nil } // RecordMysqlLocksDataPoint adds a data point to mysql.locks metric. -func (mb *MetricsBuilder) RecordMysqlLocksDataPoint(ts pcommon.Timestamp, val string, locksAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlLocksDataPoint(ts pcommon.Timestamp, val string, locksAttributeValue AttributeLocks) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlLocks, value was %s: %w", val, err) } else { - mb.metricMysqlLocks.recordDataPoint(mb.startTime, ts, i, locksAttributeValue) + mb.metricMysqlLocks.recordDataPoint(mb.startTime, ts, i, locksAttributeValue.String()) } return nil } // RecordMysqlLogOperationsDataPoint adds a data point to mysql.log_operations metric. -func (mb *MetricsBuilder) RecordMysqlLogOperationsDataPoint(ts pcommon.Timestamp, val string, logOperationsAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlLogOperationsDataPoint(ts pcommon.Timestamp, val string, logOperationsAttributeValue AttributeLogOperations) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlLogOperations, value was %s: %w", val, err) } else { - mb.metricMysqlLogOperations.recordDataPoint(mb.startTime, ts, i, logOperationsAttributeValue) + mb.metricMysqlLogOperations.recordDataPoint(mb.startTime, ts, i, logOperationsAttributeValue.String()) } return nil } // RecordMysqlOperationsDataPoint adds a data point to mysql.operations metric. -func (mb *MetricsBuilder) RecordMysqlOperationsDataPoint(ts pcommon.Timestamp, val string, operationsAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlOperationsDataPoint(ts pcommon.Timestamp, val string, operationsAttributeValue AttributeOperations) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlOperations, value was %s: %w", val, err) } else { - mb.metricMysqlOperations.recordDataPoint(mb.startTime, ts, i, operationsAttributeValue) + mb.metricMysqlOperations.recordDataPoint(mb.startTime, ts, i, operationsAttributeValue.String()) } return nil } // RecordMysqlPageOperationsDataPoint adds a data point to mysql.page_operations metric. -func (mb *MetricsBuilder) RecordMysqlPageOperationsDataPoint(ts pcommon.Timestamp, val string, pageOperationsAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlPageOperationsDataPoint(ts pcommon.Timestamp, val string, pageOperationsAttributeValue AttributePageOperations) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlPageOperations, value was %s: %w", val, err) } else { - mb.metricMysqlPageOperations.recordDataPoint(mb.startTime, ts, i, pageOperationsAttributeValue) + mb.metricMysqlPageOperations.recordDataPoint(mb.startTime, ts, i, pageOperationsAttributeValue.String()) } return nil } // RecordMysqlRowLocksDataPoint adds a data point to mysql.row_locks metric. -func (mb *MetricsBuilder) RecordMysqlRowLocksDataPoint(ts pcommon.Timestamp, val string, rowLocksAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlRowLocksDataPoint(ts pcommon.Timestamp, val string, rowLocksAttributeValue AttributeRowLocks) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlRowLocks, value was %s: %w", val, err) } else { - mb.metricMysqlRowLocks.recordDataPoint(mb.startTime, ts, i, rowLocksAttributeValue) + mb.metricMysqlRowLocks.recordDataPoint(mb.startTime, ts, i, rowLocksAttributeValue.String()) } return nil } // RecordMysqlRowOperationsDataPoint adds a data point to mysql.row_operations metric. -func (mb *MetricsBuilder) RecordMysqlRowOperationsDataPoint(ts pcommon.Timestamp, val string, rowOperationsAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlRowOperationsDataPoint(ts pcommon.Timestamp, val string, rowOperationsAttributeValue AttributeRowOperations) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlRowOperations, value was %s: %w", val, err) } else { - mb.metricMysqlRowOperations.recordDataPoint(mb.startTime, ts, i, rowOperationsAttributeValue) + mb.metricMysqlRowOperations.recordDataPoint(mb.startTime, ts, i, rowOperationsAttributeValue.String()) } return nil } // RecordMysqlSortsDataPoint adds a data point to mysql.sorts metric. -func (mb *MetricsBuilder) RecordMysqlSortsDataPoint(ts pcommon.Timestamp, val string, sortsAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlSortsDataPoint(ts pcommon.Timestamp, val string, sortsAttributeValue AttributeSorts) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlSorts, value was %s: %w", val, err) } else { - mb.metricMysqlSorts.recordDataPoint(mb.startTime, ts, i, sortsAttributeValue) + mb.metricMysqlSorts.recordDataPoint(mb.startTime, ts, i, sortsAttributeValue.String()) } return nil } // RecordMysqlThreadsDataPoint adds a data point to mysql.threads metric. -func (mb *MetricsBuilder) RecordMysqlThreadsDataPoint(ts pcommon.Timestamp, val string, threadsAttributeValue string) error { +func (mb *MetricsBuilder) RecordMysqlThreadsDataPoint(ts pcommon.Timestamp, val string, threadsAttributeValue AttributeThreads) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for MysqlThreads, value was %s: %w", val, err) } else { - mb.metricMysqlThreads.recordDataPoint(mb.startTime, ts, i, threadsAttributeValue) + mb.metricMysqlThreads.recordDataPoint(mb.startTime, ts, i, threadsAttributeValue.String()) } return nil } @@ -1331,199 +1835,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeBufferPoolData are the possible values that the attribute "buffer_pool_data" can have. -var AttributeBufferPoolData = struct { - Dirty string - Clean string -}{ - "dirty", - "clean", -} - -// AttributeBufferPoolOperations are the possible values that the attribute "buffer_pool_operations" can have. -var AttributeBufferPoolOperations = struct { - ReadAheadRnd string - ReadAhead string - ReadAheadEvicted string - ReadRequests string - Reads string - WaitFree string - WriteRequests string -}{ - "read_ahead_rnd", - "read_ahead", - "read_ahead_evicted", - "read_requests", - "reads", - "wait_free", - "write_requests", -} - -// AttributeBufferPoolPages are the possible values that the attribute "buffer_pool_pages" can have. -var AttributeBufferPoolPages = struct { - Data string - Free string - Misc string -}{ - "data", - "free", - "misc", -} - -// AttributeCommand are the possible values that the attribute "command" can have. -var AttributeCommand = struct { - Execute string - Close string - Fetch string - Prepare string - Reset string - SendLongData string -}{ - "execute", - "close", - "fetch", - "prepare", - "reset", - "send_long_data", -} - -// AttributeDoubleWrites are the possible values that the attribute "double_writes" can have. -var AttributeDoubleWrites = struct { - PagesWritten string - Writes string -}{ - "pages_written", - "writes", -} - -// AttributeHandler are the possible values that the attribute "handler" can have. -var AttributeHandler = struct { - Commit string - Delete string - Discover string - ExternalLock string - MrrInit string - Prepare string - ReadFirst string - ReadKey string - ReadLast string - ReadNext string - ReadPrev string - ReadRnd string - ReadRndNext string - Rollback string - Savepoint string - SavepointRollback string - Update string - Write string -}{ - "commit", - "delete", - "discover", - "external_lock", - "mrr_init", - "prepare", - "read_first", - "read_key", - "read_last", - "read_next", - "read_prev", - "read_rnd", - "read_rnd_next", - "rollback", - "savepoint", - "savepoint_rollback", - "update", - "write", -} - -// AttributeLocks are the possible values that the attribute "locks" can have. -var AttributeLocks = struct { - Immediate string - Waited string -}{ - "immediate", - "waited", -} - -// AttributeLogOperations are the possible values that the attribute "log_operations" can have. -var AttributeLogOperations = struct { - Waits string - WriteRequests string - Writes string -}{ - "waits", - "write_requests", - "writes", -} - -// AttributeOperations are the possible values that the attribute "operations" can have. -var AttributeOperations = struct { - Fsyncs string - Reads string - Writes string -}{ - "fsyncs", - "reads", - "writes", -} - -// AttributePageOperations are the possible values that the attribute "page_operations" can have. -var AttributePageOperations = struct { - Created string - Read string - Written string -}{ - "created", - "read", - "written", -} - -// AttributeRowLocks are the possible values that the attribute "row_locks" can have. -var AttributeRowLocks = struct { - Waits string - Time string -}{ - "waits", - "time", -} - -// AttributeRowOperations are the possible values that the attribute "row_operations" can have. -var AttributeRowOperations = struct { - Deleted string - Inserted string - Read string - Updated string -}{ - "deleted", - "inserted", - "read", - "updated", -} - -// AttributeSorts are the possible values that the attribute "sorts" can have. -var AttributeSorts = struct { - MergePasses string - Range string - Rows string - Scan string -}{ - "merge_passes", - "range", - "rows", - "scan", -} - -// AttributeThreads are the possible values that the attribute "threads" can have. -var AttributeThreads = struct { - Cached string - Connected string - Created string - Running string -}{ - "cached", - "connected", - "created", - "running", -} diff --git a/receiver/mysqlreceiver/scraper.go b/receiver/mysqlreceiver/scraper.go index 353e49ed076a..9aa1f6381ed4 100644 --- a/receiver/mysqlreceiver/scraper.go +++ b/receiver/mysqlreceiver/scraper.go @@ -105,11 +105,14 @@ func (m *mySQLScraper) scrape(context.Context) (pmetric.Metrics, error) { // buffer_pool.pages case "Innodb_buffer_pool_pages_data": - addPartialIfError(errors, m.mb.RecordMysqlBufferPoolPagesDataPoint(now, v, "data")) + addPartialIfError(errors, m.mb.RecordMysqlBufferPoolPagesDataPoint(now, v, + metadata.AttributeBufferPoolPagesData)) case "Innodb_buffer_pool_pages_free": - addPartialIfError(errors, m.mb.RecordMysqlBufferPoolPagesDataPoint(now, v, "free")) + addPartialIfError(errors, m.mb.RecordMysqlBufferPoolPagesDataPoint(now, v, + metadata.AttributeBufferPoolPagesFree)) case "Innodb_buffer_pool_pages_misc": - addPartialIfError(errors, m.mb.RecordMysqlBufferPoolPagesDataPoint(now, v, "misc")) + addPartialIfError(errors, m.mb.RecordMysqlBufferPoolPagesDataPoint(now, v, + metadata.AttributeBufferPoolPagesMisc)) // buffer_pool.page_flushes case "Innodb_buffer_pool_pages_flushed": @@ -117,143 +120,154 @@ func (m *mySQLScraper) scrape(context.Context) (pmetric.Metrics, error) { // buffer_pool.operations case "Innodb_buffer_pool_read_ahead_rnd": - addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, "read_ahead_rnd")) + addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, + metadata.AttributeBufferPoolOperationsReadAheadRnd)) case "Innodb_buffer_pool_read_ahead": - addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, "read_ahead")) + addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, + metadata.AttributeBufferPoolOperationsReadAhead)) case "Innodb_buffer_pool_read_ahead_evicted": - addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, "read_ahead_evicted")) + addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, + metadata.AttributeBufferPoolOperationsReadAheadEvicted)) case "Innodb_buffer_pool_read_requests": - addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, "read_requests")) + addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, + metadata.AttributeBufferPoolOperationsReadRequests)) case "Innodb_buffer_pool_reads": - addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, "reads")) + addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, + metadata.AttributeBufferPoolOperationsReads)) case "Innodb_buffer_pool_wait_free": - addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, "wait_free")) + addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, + metadata.AttributeBufferPoolOperationsWaitFree)) case "Innodb_buffer_pool_write_requests": - addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, "write_requests")) + addPartialIfError(errors, m.mb.RecordMysqlBufferPoolOperationsDataPoint(now, v, + metadata.AttributeBufferPoolOperationsWriteRequests)) // commands case "Com_stmt_execute": - addPartialIfError(errors, m.mb.RecordMysqlCommandsDataPoint(now, v, "execute")) + addPartialIfError(errors, m.mb.RecordMysqlCommandsDataPoint(now, v, metadata.AttributeCommandExecute)) case "Com_stmt_close": - addPartialIfError(errors, m.mb.RecordMysqlCommandsDataPoint(now, v, "close")) + addPartialIfError(errors, m.mb.RecordMysqlCommandsDataPoint(now, v, metadata.AttributeCommandClose)) case "Com_stmt_fetch": - addPartialIfError(errors, m.mb.RecordMysqlCommandsDataPoint(now, v, "fetch")) + addPartialIfError(errors, m.mb.RecordMysqlCommandsDataPoint(now, v, metadata.AttributeCommandFetch)) case "Com_stmt_prepare": - addPartialIfError(errors, m.mb.RecordMysqlCommandsDataPoint(now, v, "prepare")) + addPartialIfError(errors, m.mb.RecordMysqlCommandsDataPoint(now, v, metadata.AttributeCommandPrepare)) case "Com_stmt_reset": - addPartialIfError(errors, m.mb.RecordMysqlCommandsDataPoint(now, v, "reset")) + addPartialIfError(errors, m.mb.RecordMysqlCommandsDataPoint(now, v, metadata.AttributeCommandReset)) case "Com_stmt_send_long_data": - addPartialIfError(errors, m.mb.RecordMysqlCommandsDataPoint(now, v, "send_long_data")) + addPartialIfError(errors, m.mb.RecordMysqlCommandsDataPoint(now, v, metadata.AttributeCommandSendLongData)) // handlers case "Handler_commit": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "commit")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerCommit)) case "Handler_delete": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "delete")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerDelete)) case "Handler_discover": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "discover")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerDiscover)) case "Handler_external_lock": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "external_lock")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerExternalLock)) case "Handler_mrr_init": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "mrr_init")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerMrrInit)) case "Handler_prepare": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "prepare")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerPrepare)) case "Handler_read_first": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "read_first")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerReadFirst)) case "Handler_read_key": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "read_key")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerReadKey)) case "Handler_read_last": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "read_last")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerReadLast)) case "Handler_read_next": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "read_next")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerReadNext)) case "Handler_read_prev": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "read_prev")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerReadPrev)) case "Handler_read_rnd": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "read_rnd")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerReadRnd)) case "Handler_read_rnd_next": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "read_rnd_next")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerReadRndNext)) case "Handler_rollback": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "rollback")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerRollback)) case "Handler_savepoint": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "savepoint")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerSavepoint)) case "Handler_savepoint_rollback": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "savepoint_rollback")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerSavepointRollback)) case "Handler_update": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "update")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerUpdate)) case "Handler_write": - addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, "write")) + addPartialIfError(errors, m.mb.RecordMysqlHandlersDataPoint(now, v, metadata.AttributeHandlerWrite)) // double_writes case "Innodb_dblwr_pages_written": - addPartialIfError(errors, m.mb.RecordMysqlDoubleWritesDataPoint(now, v, "pages_written")) + addPartialIfError(errors, m.mb.RecordMysqlDoubleWritesDataPoint(now, v, metadata.AttributeDoubleWritesPagesWritten)) case "Innodb_dblwr_writes": - addPartialIfError(errors, m.mb.RecordMysqlDoubleWritesDataPoint(now, v, "writes")) + addPartialIfError(errors, m.mb.RecordMysqlDoubleWritesDataPoint(now, v, metadata.AttributeDoubleWritesWrites)) // log_operations case "Innodb_log_waits": - addPartialIfError(errors, m.mb.RecordMysqlLogOperationsDataPoint(now, v, "waits")) + addPartialIfError(errors, m.mb.RecordMysqlLogOperationsDataPoint(now, v, metadata.AttributeLogOperationsWaits)) case "Innodb_log_write_requests": - addPartialIfError(errors, m.mb.RecordMysqlLogOperationsDataPoint(now, v, "write_requests")) + addPartialIfError(errors, m.mb.RecordMysqlLogOperationsDataPoint(now, v, metadata.AttributeLogOperationsWriteRequests)) case "Innodb_log_writes": - addPartialIfError(errors, m.mb.RecordMysqlLogOperationsDataPoint(now, v, "writes")) + addPartialIfError(errors, m.mb.RecordMysqlLogOperationsDataPoint(now, v, metadata.AttributeLogOperationsWrites)) // operations case "Innodb_data_fsyncs": - addPartialIfError(errors, m.mb.RecordMysqlOperationsDataPoint(now, v, "fsyncs")) + addPartialIfError(errors, m.mb.RecordMysqlOperationsDataPoint(now, v, metadata.AttributeOperationsFsyncs)) case "Innodb_data_reads": - addPartialIfError(errors, m.mb.RecordMysqlOperationsDataPoint(now, v, "reads")) + addPartialIfError(errors, m.mb.RecordMysqlOperationsDataPoint(now, v, metadata.AttributeOperationsReads)) case "Innodb_data_writes": - addPartialIfError(errors, m.mb.RecordMysqlOperationsDataPoint(now, v, "writes")) + addPartialIfError(errors, m.mb.RecordMysqlOperationsDataPoint(now, v, metadata.AttributeOperationsWrites)) // page_operations case "Innodb_pages_created": - addPartialIfError(errors, m.mb.RecordMysqlPageOperationsDataPoint(now, v, "created")) + addPartialIfError(errors, m.mb.RecordMysqlPageOperationsDataPoint(now, v, metadata.AttributePageOperationsCreated)) case "Innodb_pages_read": - addPartialIfError(errors, m.mb.RecordMysqlPageOperationsDataPoint(now, v, "read")) + addPartialIfError(errors, m.mb.RecordMysqlPageOperationsDataPoint(now, v, + metadata.AttributePageOperationsRead)) case "Innodb_pages_written": - addPartialIfError(errors, m.mb.RecordMysqlPageOperationsDataPoint(now, v, "written")) + addPartialIfError(errors, m.mb.RecordMysqlPageOperationsDataPoint(now, v, + metadata.AttributePageOperationsWritten)) // row_locks case "Innodb_row_lock_waits": - addPartialIfError(errors, m.mb.RecordMysqlRowLocksDataPoint(now, v, "waits")) + addPartialIfError(errors, m.mb.RecordMysqlRowLocksDataPoint(now, v, metadata.AttributeRowLocksWaits)) case "Innodb_row_lock_time": - addPartialIfError(errors, m.mb.RecordMysqlRowLocksDataPoint(now, v, "time")) + addPartialIfError(errors, m.mb.RecordMysqlRowLocksDataPoint(now, v, metadata.AttributeRowLocksTime)) // row_operations case "Innodb_rows_deleted": - addPartialIfError(errors, m.mb.RecordMysqlRowOperationsDataPoint(now, v, "deleted")) + addPartialIfError(errors, m.mb.RecordMysqlRowOperationsDataPoint(now, v, metadata.AttributeRowOperationsDeleted)) case "Innodb_rows_inserted": - addPartialIfError(errors, m.mb.RecordMysqlRowOperationsDataPoint(now, v, "inserted")) + addPartialIfError(errors, m.mb.RecordMysqlRowOperationsDataPoint(now, v, metadata.AttributeRowOperationsInserted)) case "Innodb_rows_read": - addPartialIfError(errors, m.mb.RecordMysqlRowOperationsDataPoint(now, v, "read")) + addPartialIfError(errors, m.mb.RecordMysqlRowOperationsDataPoint(now, v, + metadata.AttributeRowOperationsRead)) case "Innodb_rows_updated": - addPartialIfError(errors, m.mb.RecordMysqlRowOperationsDataPoint(now, v, "updated")) + addPartialIfError(errors, m.mb.RecordMysqlRowOperationsDataPoint(now, v, + metadata.AttributeRowOperationsUpdated)) // locks case "Table_locks_immediate": - addPartialIfError(errors, m.mb.RecordMysqlLocksDataPoint(now, v, "immediate")) + addPartialIfError(errors, m.mb.RecordMysqlLocksDataPoint(now, v, metadata.AttributeLocksImmediate)) case "Table_locks_waited": - addPartialIfError(errors, m.mb.RecordMysqlLocksDataPoint(now, v, "waited")) + addPartialIfError(errors, m.mb.RecordMysqlLocksDataPoint(now, v, metadata.AttributeLocksWaited)) // sorts case "Sort_merge_passes": - addPartialIfError(errors, m.mb.RecordMysqlSortsDataPoint(now, v, "merge_passes")) + addPartialIfError(errors, m.mb.RecordMysqlSortsDataPoint(now, v, metadata.AttributeSortsMergePasses)) case "Sort_range": - addPartialIfError(errors, m.mb.RecordMysqlSortsDataPoint(now, v, "range")) + addPartialIfError(errors, m.mb.RecordMysqlSortsDataPoint(now, v, metadata.AttributeSortsRange)) case "Sort_rows": - addPartialIfError(errors, m.mb.RecordMysqlSortsDataPoint(now, v, "rows")) + addPartialIfError(errors, m.mb.RecordMysqlSortsDataPoint(now, v, metadata.AttributeSortsRows)) case "Sort_scan": - addPartialIfError(errors, m.mb.RecordMysqlSortsDataPoint(now, v, "scan")) + addPartialIfError(errors, m.mb.RecordMysqlSortsDataPoint(now, v, metadata.AttributeSortsScan)) // threads case "Threads_cached": - addPartialIfError(errors, m.mb.RecordMysqlThreadsDataPoint(now, v, "cached")) + addPartialIfError(errors, m.mb.RecordMysqlThreadsDataPoint(now, v, metadata.AttributeThreadsCached)) case "Threads_connected": - addPartialIfError(errors, m.mb.RecordMysqlThreadsDataPoint(now, v, "connected")) + addPartialIfError(errors, m.mb.RecordMysqlThreadsDataPoint(now, v, metadata.AttributeThreadsConnected)) case "Threads_created": - addPartialIfError(errors, m.mb.RecordMysqlThreadsDataPoint(now, v, "created")) + addPartialIfError(errors, m.mb.RecordMysqlThreadsDataPoint(now, v, metadata.AttributeThreadsCreated)) case "Threads_running": - addPartialIfError(errors, m.mb.RecordMysqlThreadsDataPoint(now, v, "running")) + addPartialIfError(errors, m.mb.RecordMysqlThreadsDataPoint(now, v, metadata.AttributeThreadsRunning)) } } @@ -272,14 +286,14 @@ func (m *mySQLScraper) recordDataPages(now pcommon.Timestamp, globalStats map[st errors.AddPartial(2, err) // we need dirty to calculate free, so 2 data points lost here return } - m.mb.RecordMysqlBufferPoolDataPagesDataPoint(now, dirty, "dirty") + m.mb.RecordMysqlBufferPoolDataPagesDataPoint(now, dirty, metadata.AttributeBufferPoolDataDirty) data, err := parseInt(globalStats["Innodb_buffer_pool_pages_data"]) if err != nil { errors.AddPartial(1, err) return } - m.mb.RecordMysqlBufferPoolDataPagesDataPoint(now, data-dirty, "clean") + m.mb.RecordMysqlBufferPoolDataPagesDataPoint(now, data-dirty, metadata.AttributeBufferPoolDataClean) } func (m *mySQLScraper) recordDataUsage(now pcommon.Timestamp, globalStats map[string]string, errors scrapererror.ScrapeErrors) { @@ -288,14 +302,14 @@ func (m *mySQLScraper) recordDataUsage(now pcommon.Timestamp, globalStats map[st errors.AddPartial(2, err) // we need dirty to calculate free, so 2 data points lost here return } - m.mb.RecordMysqlBufferPoolUsageDataPoint(now, dirty, "dirty") + m.mb.RecordMysqlBufferPoolUsageDataPoint(now, dirty, metadata.AttributeBufferPoolDataDirty) data, err := parseInt(globalStats["Innodb_buffer_pool_bytes_data"]) if err != nil { errors.AddPartial(1, err) return } - m.mb.RecordMysqlBufferPoolUsageDataPoint(now, data-dirty, "clean") + m.mb.RecordMysqlBufferPoolUsageDataPoint(now, data-dirty, metadata.AttributeBufferPoolDataClean) } // parseInt converts string to int64. diff --git a/receiver/nginxreceiver/internal/metadata/generated_metrics_v2.go b/receiver/nginxreceiver/internal/metadata/generated_metrics_v2.go index a27d7d74b805..cef75e393e0f 100644 --- a/receiver/nginxreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/nginxreceiver/internal/metadata/generated_metrics_v2.go @@ -39,6 +39,40 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeState specifies the a value state attribute. +type AttributeState int + +const ( + _ AttributeState = iota + AttributeStateActive + AttributeStateReading + AttributeStateWriting + AttributeStateWaiting +) + +// String returns the string representation of the AttributeState. +func (av AttributeState) String() string { + switch av { + case AttributeStateActive: + return "active" + case AttributeStateReading: + return "reading" + case AttributeStateWriting: + return "writing" + case AttributeStateWaiting: + return "waiting" + } + return "" +} + +// MapAttributeState is a helper map of string to AttributeState attribute value. +var MapAttributeState = map[string]AttributeState{ + "active": AttributeStateActive, + "reading": AttributeStateReading, + "writing": AttributeStateWriting, + "waiting": AttributeStateWaiting, +} + type metricNginxConnectionsAccepted struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -333,8 +367,8 @@ func (mb *MetricsBuilder) RecordNginxConnectionsAcceptedDataPoint(ts pcommon.Tim } // RecordNginxConnectionsCurrentDataPoint adds a data point to nginx.connections_current metric. -func (mb *MetricsBuilder) RecordNginxConnectionsCurrentDataPoint(ts pcommon.Timestamp, val int64, stateAttributeValue string) { - mb.metricNginxConnectionsCurrent.recordDataPoint(mb.startTime, ts, val, stateAttributeValue) +func (mb *MetricsBuilder) RecordNginxConnectionsCurrentDataPoint(ts pcommon.Timestamp, val int64, stateAttributeValue AttributeState) { + mb.metricNginxConnectionsCurrent.recordDataPoint(mb.startTime, ts, val, stateAttributeValue.String()) } // RecordNginxConnectionsHandledDataPoint adds a data point to nginx.connections_handled metric. @@ -366,16 +400,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeState are the possible values that the attribute "state" can have. -var AttributeState = struct { - Active string - Reading string - Writing string - Waiting string -}{ - "active", - "reading", - "writing", - "waiting", -} diff --git a/receiver/nginxreceiver/scraper.go b/receiver/nginxreceiver/scraper.go index a79dcd70d823..a1752009edd4 100644 --- a/receiver/nginxreceiver/scraper.go +++ b/receiver/nginxreceiver/scraper.go @@ -80,10 +80,10 @@ func (r *nginxScraper) scrape(context.Context) (pmetric.Metrics, error) { r.mb.RecordNginxRequestsDataPoint(now, stats.Requests) r.mb.RecordNginxConnectionsAcceptedDataPoint(now, stats.Connections.Accepted) r.mb.RecordNginxConnectionsHandledDataPoint(now, stats.Connections.Handled) - r.mb.RecordNginxConnectionsCurrentDataPoint(now, stats.Connections.Active, metadata.AttributeState.Active) - r.mb.RecordNginxConnectionsCurrentDataPoint(now, stats.Connections.Reading, metadata.AttributeState.Reading) - r.mb.RecordNginxConnectionsCurrentDataPoint(now, stats.Connections.Writing, metadata.AttributeState.Writing) - r.mb.RecordNginxConnectionsCurrentDataPoint(now, stats.Connections.Waiting, metadata.AttributeState.Waiting) + r.mb.RecordNginxConnectionsCurrentDataPoint(now, stats.Connections.Active, metadata.AttributeStateActive) + r.mb.RecordNginxConnectionsCurrentDataPoint(now, stats.Connections.Reading, metadata.AttributeStateReading) + r.mb.RecordNginxConnectionsCurrentDataPoint(now, stats.Connections.Writing, metadata.AttributeStateWriting) + r.mb.RecordNginxConnectionsCurrentDataPoint(now, stats.Connections.Waiting, metadata.AttributeStateWaiting) return r.mb.Emit(), nil } diff --git a/receiver/postgresqlreceiver/internal/metadata/generated_metrics_v2.go b/receiver/postgresqlreceiver/internal/metadata/generated_metrics_v2.go index dfe3623211b1..6454d04ea79f 100644 --- a/receiver/postgresqlreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/postgresqlreceiver/internal/metadata/generated_metrics_v2.go @@ -51,6 +51,116 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeOperation specifies the a value operation attribute. +type AttributeOperation int + +const ( + _ AttributeOperation = iota + AttributeOperationIns + AttributeOperationUpd + AttributeOperationDel + AttributeOperationHotUpd +) + +// String returns the string representation of the AttributeOperation. +func (av AttributeOperation) String() string { + switch av { + case AttributeOperationIns: + return "ins" + case AttributeOperationUpd: + return "upd" + case AttributeOperationDel: + return "del" + case AttributeOperationHotUpd: + return "hot_upd" + } + return "" +} + +// MapAttributeOperation is a helper map of string to AttributeOperation attribute value. +var MapAttributeOperation = map[string]AttributeOperation{ + "ins": AttributeOperationIns, + "upd": AttributeOperationUpd, + "del": AttributeOperationDel, + "hot_upd": AttributeOperationHotUpd, +} + +// AttributeSource specifies the a value source attribute. +type AttributeSource int + +const ( + _ AttributeSource = iota + AttributeSourceHeapRead + AttributeSourceHeapHit + AttributeSourceIdxRead + AttributeSourceIdxHit + AttributeSourceToastRead + AttributeSourceToastHit + AttributeSourceTidxRead + AttributeSourceTidxHit +) + +// String returns the string representation of the AttributeSource. +func (av AttributeSource) String() string { + switch av { + case AttributeSourceHeapRead: + return "heap_read" + case AttributeSourceHeapHit: + return "heap_hit" + case AttributeSourceIdxRead: + return "idx_read" + case AttributeSourceIdxHit: + return "idx_hit" + case AttributeSourceToastRead: + return "toast_read" + case AttributeSourceToastHit: + return "toast_hit" + case AttributeSourceTidxRead: + return "tidx_read" + case AttributeSourceTidxHit: + return "tidx_hit" + } + return "" +} + +// MapAttributeSource is a helper map of string to AttributeSource attribute value. +var MapAttributeSource = map[string]AttributeSource{ + "heap_read": AttributeSourceHeapRead, + "heap_hit": AttributeSourceHeapHit, + "idx_read": AttributeSourceIdxRead, + "idx_hit": AttributeSourceIdxHit, + "toast_read": AttributeSourceToastRead, + "toast_hit": AttributeSourceToastHit, + "tidx_read": AttributeSourceTidxRead, + "tidx_hit": AttributeSourceTidxHit, +} + +// AttributeState specifies the a value state attribute. +type AttributeState int + +const ( + _ AttributeState = iota + AttributeStateDead + AttributeStateLive +) + +// String returns the string representation of the AttributeState. +func (av AttributeState) String() string { + switch av { + case AttributeStateDead: + return "dead" + case AttributeStateLive: + return "live" + } + return "" +} + +// MapAttributeState is a helper map of string to AttributeState attribute value. +var MapAttributeState = map[string]AttributeState{ + "dead": AttributeStateDead, + "live": AttributeStateLive, +} + type metricPostgresqlBackends struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -527,8 +637,8 @@ func (mb *MetricsBuilder) RecordPostgresqlBackendsDataPoint(ts pcommon.Timestamp } // RecordPostgresqlBlocksReadDataPoint adds a data point to postgresql.blocks_read metric. -func (mb *MetricsBuilder) RecordPostgresqlBlocksReadDataPoint(ts pcommon.Timestamp, val int64, databaseAttributeValue string, tableAttributeValue string, sourceAttributeValue string) { - mb.metricPostgresqlBlocksRead.recordDataPoint(mb.startTime, ts, val, databaseAttributeValue, tableAttributeValue, sourceAttributeValue) +func (mb *MetricsBuilder) RecordPostgresqlBlocksReadDataPoint(ts pcommon.Timestamp, val int64, databaseAttributeValue string, tableAttributeValue string, sourceAttributeValue AttributeSource) { + mb.metricPostgresqlBlocksRead.recordDataPoint(mb.startTime, ts, val, databaseAttributeValue, tableAttributeValue, sourceAttributeValue.String()) } // RecordPostgresqlCommitsDataPoint adds a data point to postgresql.commits metric. @@ -542,8 +652,8 @@ func (mb *MetricsBuilder) RecordPostgresqlDbSizeDataPoint(ts pcommon.Timestamp, } // RecordPostgresqlOperationsDataPoint adds a data point to postgresql.operations metric. -func (mb *MetricsBuilder) RecordPostgresqlOperationsDataPoint(ts pcommon.Timestamp, val int64, databaseAttributeValue string, tableAttributeValue string, operationAttributeValue string) { - mb.metricPostgresqlOperations.recordDataPoint(mb.startTime, ts, val, databaseAttributeValue, tableAttributeValue, operationAttributeValue) +func (mb *MetricsBuilder) RecordPostgresqlOperationsDataPoint(ts pcommon.Timestamp, val int64, databaseAttributeValue string, tableAttributeValue string, operationAttributeValue AttributeOperation) { + mb.metricPostgresqlOperations.recordDataPoint(mb.startTime, ts, val, databaseAttributeValue, tableAttributeValue, operationAttributeValue.String()) } // RecordPostgresqlRollbacksDataPoint adds a data point to postgresql.rollbacks metric. @@ -552,8 +662,8 @@ func (mb *MetricsBuilder) RecordPostgresqlRollbacksDataPoint(ts pcommon.Timestam } // RecordPostgresqlRowsDataPoint adds a data point to postgresql.rows metric. -func (mb *MetricsBuilder) RecordPostgresqlRowsDataPoint(ts pcommon.Timestamp, val int64, databaseAttributeValue string, tableAttributeValue string, stateAttributeValue string) { - mb.metricPostgresqlRows.recordDataPoint(mb.startTime, ts, val, databaseAttributeValue, tableAttributeValue, stateAttributeValue) +func (mb *MetricsBuilder) RecordPostgresqlRowsDataPoint(ts pcommon.Timestamp, val int64, databaseAttributeValue string, tableAttributeValue string, stateAttributeValue AttributeState) { + mb.metricPostgresqlRows.recordDataPoint(mb.startTime, ts, val, databaseAttributeValue, tableAttributeValue, stateAttributeValue.String()) } // Reset resets metrics builder to its initial state. It should be used when external metrics source is restarted, @@ -587,46 +697,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeOperation are the possible values that the attribute "operation" can have. -var AttributeOperation = struct { - Ins string - Upd string - Del string - HotUpd string -}{ - "ins", - "upd", - "del", - "hot_upd", -} - -// AttributeSource are the possible values that the attribute "source" can have. -var AttributeSource = struct { - HeapRead string - HeapHit string - IdxRead string - IdxHit string - ToastRead string - ToastHit string - TidxRead string - TidxHit string -}{ - "heap_read", - "heap_hit", - "idx_read", - "idx_hit", - "toast_read", - "toast_hit", - "tidx_read", - "tidx_hit", -} - -// AttributeState are the possible values that the attribute "state" can have. -var AttributeState = struct { - Dead string - Live string -}{ - "dead", - "live", -} diff --git a/receiver/postgresqlreceiver/scraper.go b/receiver/postgresqlreceiver/scraper.go index b79e97009ac5..4840e2aadf41 100644 --- a/receiver/postgresqlreceiver/scraper.go +++ b/receiver/postgresqlreceiver/scraper.go @@ -123,13 +123,18 @@ func (p *postgreSQLScraper) collectBlockReads( return } for _, table := range blocksReadByTableMetrics { - for k, v := range table.stats { - i, err := p.parseInt(k, v) + for sourceKey, source := range metadata.MapAttributeSource { + value, ok := table.stats[sourceKey] + if !ok { + // Data isn't present, error was already logged at a lower level + continue + } + i, err := p.parseInt(sourceKey, value) if err != nil { errors.AddPartial(0, err) continue } - p.mb.RecordPostgresqlBlocksReadDataPoint(now, i, table.database, table.table, k) + p.mb.RecordPostgresqlBlocksReadDataPoint(now, i, table.database, table.table, source) } } } @@ -151,32 +156,32 @@ func (p *postgreSQLScraper) collectDatabaseTableMetrics( return } for _, table := range databaseTableMetrics { - for _, key := range []string{"live", "dead"} { - value, ok := table.stats[key] + for stateKey, state := range metadata.MapAttributeState { + value, ok := table.stats[stateKey] if !ok { // Data isn't present, error was already logged at a lower level continue } - i, err := p.parseInt(key, value) + i, err := p.parseInt(stateKey, value) if err != nil { errors.AddPartial(0, err) continue } - p.mb.RecordPostgresqlRowsDataPoint(now, i, table.database, table.table, key) + p.mb.RecordPostgresqlRowsDataPoint(now, i, table.database, table.table, state) } - for _, key := range []string{"ins", "upd", "del", "hot_upd"} { - value, ok := table.stats[key] + for opKey, op := range metadata.MapAttributeOperation { + value, ok := table.stats[opKey] if !ok { // Data isn't present, error was already logged at a lower level continue } - i, err := p.parseInt(key, value) + i, err := p.parseInt(opKey, value) if err != nil { errors.AddPartial(0, err) continue } - p.mb.RecordPostgresqlOperationsDataPoint(now, i, table.database, table.table, key) + p.mb.RecordPostgresqlOperationsDataPoint(now, i, table.database, table.table, op) } } } diff --git a/receiver/rabbitmqreceiver/internal/metadata/generated_metrics_v2.go b/receiver/rabbitmqreceiver/internal/metadata/generated_metrics_v2.go index 6ba10d322da0..9fc0dd8c56bb 100644 --- a/receiver/rabbitmqreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/rabbitmqreceiver/internal/metadata/generated_metrics_v2.go @@ -47,6 +47,32 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeMessageState specifies the a value message.state attribute. +type AttributeMessageState int + +const ( + _ AttributeMessageState = iota + AttributeMessageStateReady + AttributeMessageStateUnacknowledged +) + +// String returns the string representation of the AttributeMessageState. +func (av AttributeMessageState) String() string { + switch av { + case AttributeMessageStateReady: + return "ready" + case AttributeMessageStateUnacknowledged: + return "unacknowledged" + } + return "" +} + +// MapAttributeMessageState is a helper map of string to AttributeMessageState attribute value. +var MapAttributeMessageState = map[string]AttributeMessageState{ + "ready": AttributeMessageStateReady, + "unacknowledged": AttributeMessageStateUnacknowledged, +} + type metricRabbitmqConsumerCount struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -477,8 +503,8 @@ func (mb *MetricsBuilder) RecordRabbitmqMessageAcknowledgedDataPoint(ts pcommon. } // RecordRabbitmqMessageCurrentDataPoint adds a data point to rabbitmq.message.current metric. -func (mb *MetricsBuilder) RecordRabbitmqMessageCurrentDataPoint(ts pcommon.Timestamp, val int64, messageStateAttributeValue string) { - mb.metricRabbitmqMessageCurrent.recordDataPoint(mb.startTime, ts, val, messageStateAttributeValue) +func (mb *MetricsBuilder) RecordRabbitmqMessageCurrentDataPoint(ts pcommon.Timestamp, val int64, messageStateAttributeValue AttributeMessageState) { + mb.metricRabbitmqMessageCurrent.recordDataPoint(mb.startTime, ts, val, messageStateAttributeValue.String()) } // RecordRabbitmqMessageDeliveredDataPoint adds a data point to rabbitmq.message.delivered metric. @@ -515,12 +541,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeMessageState are the possible values that the attribute "message.state" can have. -var AttributeMessageState = struct { - Ready string - Unacknowledged string -}{ - "ready", - "unacknowledged", -} diff --git a/receiver/rabbitmqreceiver/scraper.go b/receiver/rabbitmqreceiver/scraper.go index 01207ae2939e..f687c85a51e6 100644 --- a/receiver/rabbitmqreceiver/scraper.go +++ b/receiver/rabbitmqreceiver/scraper.go @@ -98,8 +98,8 @@ func (r *rabbitmqScraper) scrape(ctx context.Context) (pmetric.Metrics, error) { // collectQueue collects metrics func (r *rabbitmqScraper) collectQueue(queue *models.Queue, now pcommon.Timestamp) { r.mb.RecordRabbitmqConsumerCountDataPoint(now, queue.Consumers) - r.mb.RecordRabbitmqMessageCurrentDataPoint(now, queue.UnacknowledgedMessages, metadata.AttributeMessageState.Unacknowledged) - r.mb.RecordRabbitmqMessageCurrentDataPoint(now, queue.ReadyMessages, metadata.AttributeMessageState.Ready) + r.mb.RecordRabbitmqMessageCurrentDataPoint(now, queue.UnacknowledgedMessages, metadata.AttributeMessageStateUnacknowledged) + r.mb.RecordRabbitmqMessageCurrentDataPoint(now, queue.ReadyMessages, metadata.AttributeMessageStateReady) for _, messageStatMetric := range messageStatMetrics { // Get metric value diff --git a/receiver/riakreceiver/internal/metadata/generated_metrics_v2.go b/receiver/riakreceiver/internal/metadata/generated_metrics_v2.go index a75043e844ea..88e587131e40 100644 --- a/receiver/riakreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/riakreceiver/internal/metadata/generated_metrics_v2.go @@ -47,6 +47,62 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeOperation specifies the a value operation attribute. +type AttributeOperation int + +const ( + _ AttributeOperation = iota + AttributeOperationRead + AttributeOperationWrite + AttributeOperationDelete +) + +// String returns the string representation of the AttributeOperation. +func (av AttributeOperation) String() string { + switch av { + case AttributeOperationRead: + return "read" + case AttributeOperationWrite: + return "write" + case AttributeOperationDelete: + return "delete" + } + return "" +} + +// MapAttributeOperation is a helper map of string to AttributeOperation attribute value. +var MapAttributeOperation = map[string]AttributeOperation{ + "read": AttributeOperationRead, + "write": AttributeOperationWrite, + "delete": AttributeOperationDelete, +} + +// AttributeRequest specifies the a value request attribute. +type AttributeRequest int + +const ( + _ AttributeRequest = iota + AttributeRequestPut + AttributeRequestGet +) + +// String returns the string representation of the AttributeRequest. +func (av AttributeRequest) String() string { + switch av { + case AttributeRequestPut: + return "put" + case AttributeRequestGet: + return "get" + } + return "" +} + +// MapAttributeRequest is a helper map of string to AttributeRequest attribute value. +var MapAttributeRequest = map[string]AttributeRequest{ + "put": AttributeRequestPut, + "get": AttributeRequestGet, +} + type metricRiakMemoryLimit struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -462,13 +518,13 @@ func (mb *MetricsBuilder) RecordRiakMemoryLimitDataPoint(ts pcommon.Timestamp, v } // RecordRiakNodeOperationCountDataPoint adds a data point to riak.node.operation.count metric. -func (mb *MetricsBuilder) RecordRiakNodeOperationCountDataPoint(ts pcommon.Timestamp, val int64, requestAttributeValue string) { - mb.metricRiakNodeOperationCount.recordDataPoint(mb.startTime, ts, val, requestAttributeValue) +func (mb *MetricsBuilder) RecordRiakNodeOperationCountDataPoint(ts pcommon.Timestamp, val int64, requestAttributeValue AttributeRequest) { + mb.metricRiakNodeOperationCount.recordDataPoint(mb.startTime, ts, val, requestAttributeValue.String()) } // RecordRiakNodeOperationTimeMeanDataPoint adds a data point to riak.node.operation.time.mean metric. -func (mb *MetricsBuilder) RecordRiakNodeOperationTimeMeanDataPoint(ts pcommon.Timestamp, val int64, requestAttributeValue string) { - mb.metricRiakNodeOperationTimeMean.recordDataPoint(mb.startTime, ts, val, requestAttributeValue) +func (mb *MetricsBuilder) RecordRiakNodeOperationTimeMeanDataPoint(ts pcommon.Timestamp, val int64, requestAttributeValue AttributeRequest) { + mb.metricRiakNodeOperationTimeMean.recordDataPoint(mb.startTime, ts, val, requestAttributeValue.String()) } // RecordRiakNodeReadRepairCountDataPoint adds a data point to riak.node.read_repair.count metric. @@ -477,13 +533,13 @@ func (mb *MetricsBuilder) RecordRiakNodeReadRepairCountDataPoint(ts pcommon.Time } // RecordRiakVnodeIndexOperationCountDataPoint adds a data point to riak.vnode.index.operation.count metric. -func (mb *MetricsBuilder) RecordRiakVnodeIndexOperationCountDataPoint(ts pcommon.Timestamp, val int64, operationAttributeValue string) { - mb.metricRiakVnodeIndexOperationCount.recordDataPoint(mb.startTime, ts, val, operationAttributeValue) +func (mb *MetricsBuilder) RecordRiakVnodeIndexOperationCountDataPoint(ts pcommon.Timestamp, val int64, operationAttributeValue AttributeOperation) { + mb.metricRiakVnodeIndexOperationCount.recordDataPoint(mb.startTime, ts, val, operationAttributeValue.String()) } // RecordRiakVnodeOperationCountDataPoint adds a data point to riak.vnode.operation.count metric. -func (mb *MetricsBuilder) RecordRiakVnodeOperationCountDataPoint(ts pcommon.Timestamp, val int64, requestAttributeValue string) { - mb.metricRiakVnodeOperationCount.recordDataPoint(mb.startTime, ts, val, requestAttributeValue) +func (mb *MetricsBuilder) RecordRiakVnodeOperationCountDataPoint(ts pcommon.Timestamp, val int64, requestAttributeValue AttributeRequest) { + mb.metricRiakVnodeOperationCount.recordDataPoint(mb.startTime, ts, val, requestAttributeValue.String()) } // Reset resets metrics builder to its initial state. It should be used when external metrics source is restarted, @@ -508,23 +564,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeOperation are the possible values that the attribute "operation" can have. -var AttributeOperation = struct { - Read string - Write string - Delete string -}{ - "read", - "write", - "delete", -} - -// AttributeRequest are the possible values that the attribute "request" can have. -var AttributeRequest = struct { - Put string - Get string -}{ - "put", - "get", -} diff --git a/receiver/riakreceiver/scraper.go b/receiver/riakreceiver/scraper.go index 7e08eb5ea535..0ae6c2c30591 100644 --- a/receiver/riakreceiver/scraper.go +++ b/receiver/riakreceiver/scraper.go @@ -77,12 +77,12 @@ func (r *riakScraper) collectStats(stat *model.Stats) (pmetric.Metrics, error) { now := pcommon.NewTimestampFromTime(time.Now()) var errors scrapererror.ScrapeErrors //scrape node.operation.count metric - r.mb.RecordRiakNodeOperationCountDataPoint(now, stat.NodeGets, metadata.AttributeRequest.Get) - r.mb.RecordRiakNodeOperationCountDataPoint(now, stat.NodePuts, metadata.AttributeRequest.Put) + r.mb.RecordRiakNodeOperationCountDataPoint(now, stat.NodeGets, metadata.AttributeRequestGet) + r.mb.RecordRiakNodeOperationCountDataPoint(now, stat.NodePuts, metadata.AttributeRequestPut) //scrape node.operation.time.mean metric - r.mb.RecordRiakNodeOperationTimeMeanDataPoint(now, stat.NodeGetFsmTimeMean, metadata.AttributeRequest.Get) - r.mb.RecordRiakNodeOperationTimeMeanDataPoint(now, stat.NodePutFsmTimeMean, metadata.AttributeRequest.Put) + r.mb.RecordRiakNodeOperationTimeMeanDataPoint(now, stat.NodeGetFsmTimeMean, metadata.AttributeRequestGet) + r.mb.RecordRiakNodeOperationTimeMeanDataPoint(now, stat.NodePutFsmTimeMean, metadata.AttributeRequestPut) //scrape node.read_repair.count metric r.mb.RecordRiakNodeReadRepairCountDataPoint(now, stat.ReadRepairs) @@ -91,13 +91,13 @@ func (r *riakScraper) collectStats(stat *model.Stats) (pmetric.Metrics, error) { r.mb.RecordRiakMemoryLimitDataPoint(now, stat.MemAllocated) //scrape vnode.operation.count metric - r.mb.RecordRiakVnodeOperationCountDataPoint(now, stat.VnodeGets, metadata.AttributeRequest.Get) - r.mb.RecordRiakVnodeOperationCountDataPoint(now, stat.VnodePuts, metadata.AttributeRequest.Put) + r.mb.RecordRiakVnodeOperationCountDataPoint(now, stat.VnodeGets, metadata.AttributeRequestGet) + r.mb.RecordRiakVnodeOperationCountDataPoint(now, stat.VnodePuts, metadata.AttributeRequestPut) //scrape vnode.index.operation.count metric - r.mb.RecordRiakVnodeIndexOperationCountDataPoint(now, stat.VnodeIndexReads, metadata.AttributeOperation.Read) - r.mb.RecordRiakVnodeIndexOperationCountDataPoint(now, stat.VnodeIndexWrites, metadata.AttributeOperation.Write) - r.mb.RecordRiakVnodeIndexOperationCountDataPoint(now, stat.VnodeIndexDeletes, metadata.AttributeOperation.Delete) + r.mb.RecordRiakVnodeIndexOperationCountDataPoint(now, stat.VnodeIndexReads, metadata.AttributeOperationRead) + r.mb.RecordRiakVnodeIndexOperationCountDataPoint(now, stat.VnodeIndexWrites, metadata.AttributeOperationWrite) + r.mb.RecordRiakVnodeIndexOperationCountDataPoint(now, stat.VnodeIndexDeletes, metadata.AttributeOperationDelete) return r.mb.Emit(metadata.WithRiakNodeName(stat.Node)), errors.Combine() } diff --git a/receiver/saphanareceiver/internal/metadata/generated_metrics_v2.go b/receiver/saphanareceiver/internal/metadata/generated_metrics_v2.go index dac9c3aca589..18618852d22e 100644 --- a/receiver/saphanareceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/saphanareceiver/internal/metadata/generated_metrics_v2.go @@ -205,6 +205,518 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeActivePendingRequestState specifies the a value active_pending_request_state attribute. +type AttributeActivePendingRequestState int + +const ( + _ AttributeActivePendingRequestState = iota + AttributeActivePendingRequestStateActive + AttributeActivePendingRequestStatePending +) + +// String returns the string representation of the AttributeActivePendingRequestState. +func (av AttributeActivePendingRequestState) String() string { + switch av { + case AttributeActivePendingRequestStateActive: + return "active" + case AttributeActivePendingRequestStatePending: + return "pending" + } + return "" +} + +// MapAttributeActivePendingRequestState is a helper map of string to AttributeActivePendingRequestState attribute value. +var MapAttributeActivePendingRequestState = map[string]AttributeActivePendingRequestState{ + "active": AttributeActivePendingRequestStateActive, + "pending": AttributeActivePendingRequestStatePending, +} + +// AttributeColumnMemorySubtype specifies the a value column_memory_subtype attribute. +type AttributeColumnMemorySubtype int + +const ( + _ AttributeColumnMemorySubtype = iota + AttributeColumnMemorySubtypeData + AttributeColumnMemorySubtypeDict + AttributeColumnMemorySubtypeIndex + AttributeColumnMemorySubtypeMisc +) + +// String returns the string representation of the AttributeColumnMemorySubtype. +func (av AttributeColumnMemorySubtype) String() string { + switch av { + case AttributeColumnMemorySubtypeData: + return "data" + case AttributeColumnMemorySubtypeDict: + return "dict" + case AttributeColumnMemorySubtypeIndex: + return "index" + case AttributeColumnMemorySubtypeMisc: + return "misc" + } + return "" +} + +// MapAttributeColumnMemorySubtype is a helper map of string to AttributeColumnMemorySubtype attribute value. +var MapAttributeColumnMemorySubtype = map[string]AttributeColumnMemorySubtype{ + "data": AttributeColumnMemorySubtypeData, + "dict": AttributeColumnMemorySubtypeDict, + "index": AttributeColumnMemorySubtypeIndex, + "misc": AttributeColumnMemorySubtypeMisc, +} + +// AttributeColumnMemoryType specifies the a value column_memory_type attribute. +type AttributeColumnMemoryType int + +const ( + _ AttributeColumnMemoryType = iota + AttributeColumnMemoryTypeMain + AttributeColumnMemoryTypeDelta +) + +// String returns the string representation of the AttributeColumnMemoryType. +func (av AttributeColumnMemoryType) String() string { + switch av { + case AttributeColumnMemoryTypeMain: + return "main" + case AttributeColumnMemoryTypeDelta: + return "delta" + } + return "" +} + +// MapAttributeColumnMemoryType is a helper map of string to AttributeColumnMemoryType attribute value. +var MapAttributeColumnMemoryType = map[string]AttributeColumnMemoryType{ + "main": AttributeColumnMemoryTypeMain, + "delta": AttributeColumnMemoryTypeDelta, +} + +// AttributeConnectionStatus specifies the a value connection_status attribute. +type AttributeConnectionStatus int + +const ( + _ AttributeConnectionStatus = iota + AttributeConnectionStatusRunning + AttributeConnectionStatusIdle + AttributeConnectionStatusQueueing +) + +// String returns the string representation of the AttributeConnectionStatus. +func (av AttributeConnectionStatus) String() string { + switch av { + case AttributeConnectionStatusRunning: + return "running" + case AttributeConnectionStatusIdle: + return "idle" + case AttributeConnectionStatusQueueing: + return "queueing" + } + return "" +} + +// MapAttributeConnectionStatus is a helper map of string to AttributeConnectionStatus attribute value. +var MapAttributeConnectionStatus = map[string]AttributeConnectionStatus{ + "running": AttributeConnectionStatusRunning, + "idle": AttributeConnectionStatusIdle, + "queueing": AttributeConnectionStatusQueueing, +} + +// AttributeCPUType specifies the a value cpu_type attribute. +type AttributeCPUType int + +const ( + _ AttributeCPUType = iota + AttributeCPUTypeUser + AttributeCPUTypeSystem + AttributeCPUTypeIoWait + AttributeCPUTypeIdle +) + +// String returns the string representation of the AttributeCPUType. +func (av AttributeCPUType) String() string { + switch av { + case AttributeCPUTypeUser: + return "user" + case AttributeCPUTypeSystem: + return "system" + case AttributeCPUTypeIoWait: + return "io_wait" + case AttributeCPUTypeIdle: + return "idle" + } + return "" +} + +// MapAttributeCPUType is a helper map of string to AttributeCPUType attribute value. +var MapAttributeCPUType = map[string]AttributeCPUType{ + "user": AttributeCPUTypeUser, + "system": AttributeCPUTypeSystem, + "io_wait": AttributeCPUTypeIoWait, + "idle": AttributeCPUTypeIdle, +} + +// AttributeDiskStateUsedFree specifies the a value disk_state_used_free attribute. +type AttributeDiskStateUsedFree int + +const ( + _ AttributeDiskStateUsedFree = iota + AttributeDiskStateUsedFreeUsed + AttributeDiskStateUsedFreeFree +) + +// String returns the string representation of the AttributeDiskStateUsedFree. +func (av AttributeDiskStateUsedFree) String() string { + switch av { + case AttributeDiskStateUsedFreeUsed: + return "used" + case AttributeDiskStateUsedFreeFree: + return "free" + } + return "" +} + +// MapAttributeDiskStateUsedFree is a helper map of string to AttributeDiskStateUsedFree attribute value. +var MapAttributeDiskStateUsedFree = map[string]AttributeDiskStateUsedFree{ + "used": AttributeDiskStateUsedFreeUsed, + "free": AttributeDiskStateUsedFreeFree, +} + +// AttributeHostSwapState specifies the a value host_swap_state attribute. +type AttributeHostSwapState int + +const ( + _ AttributeHostSwapState = iota + AttributeHostSwapStateUsed + AttributeHostSwapStateFree +) + +// String returns the string representation of the AttributeHostSwapState. +func (av AttributeHostSwapState) String() string { + switch av { + case AttributeHostSwapStateUsed: + return "used" + case AttributeHostSwapStateFree: + return "free" + } + return "" +} + +// MapAttributeHostSwapState is a helper map of string to AttributeHostSwapState attribute value. +var MapAttributeHostSwapState = map[string]AttributeHostSwapState{ + "used": AttributeHostSwapStateUsed, + "free": AttributeHostSwapStateFree, +} + +// AttributeInternalExternalRequestType specifies the a value internal_external_request_type attribute. +type AttributeInternalExternalRequestType int + +const ( + _ AttributeInternalExternalRequestType = iota + AttributeInternalExternalRequestTypeInternal + AttributeInternalExternalRequestTypeExternal +) + +// String returns the string representation of the AttributeInternalExternalRequestType. +func (av AttributeInternalExternalRequestType) String() string { + switch av { + case AttributeInternalExternalRequestTypeInternal: + return "internal" + case AttributeInternalExternalRequestTypeExternal: + return "external" + } + return "" +} + +// MapAttributeInternalExternalRequestType is a helper map of string to AttributeInternalExternalRequestType attribute value. +var MapAttributeInternalExternalRequestType = map[string]AttributeInternalExternalRequestType{ + "internal": AttributeInternalExternalRequestTypeInternal, + "external": AttributeInternalExternalRequestTypeExternal, +} + +// AttributeMemoryStateUsedFree specifies the a value memory_state_used_free attribute. +type AttributeMemoryStateUsedFree int + +const ( + _ AttributeMemoryStateUsedFree = iota + AttributeMemoryStateUsedFreeUsed + AttributeMemoryStateUsedFreeFree +) + +// String returns the string representation of the AttributeMemoryStateUsedFree. +func (av AttributeMemoryStateUsedFree) String() string { + switch av { + case AttributeMemoryStateUsedFreeUsed: + return "used" + case AttributeMemoryStateUsedFreeFree: + return "free" + } + return "" +} + +// MapAttributeMemoryStateUsedFree is a helper map of string to AttributeMemoryStateUsedFree attribute value. +var MapAttributeMemoryStateUsedFree = map[string]AttributeMemoryStateUsedFree{ + "used": AttributeMemoryStateUsedFreeUsed, + "free": AttributeMemoryStateUsedFreeFree, +} + +// AttributeRowMemoryType specifies the a value row_memory_type attribute. +type AttributeRowMemoryType int + +const ( + _ AttributeRowMemoryType = iota + AttributeRowMemoryTypeFixed + AttributeRowMemoryTypeVariable +) + +// String returns the string representation of the AttributeRowMemoryType. +func (av AttributeRowMemoryType) String() string { + switch av { + case AttributeRowMemoryTypeFixed: + return "fixed" + case AttributeRowMemoryTypeVariable: + return "variable" + } + return "" +} + +// MapAttributeRowMemoryType is a helper map of string to AttributeRowMemoryType attribute value. +var MapAttributeRowMemoryType = map[string]AttributeRowMemoryType{ + "fixed": AttributeRowMemoryTypeFixed, + "variable": AttributeRowMemoryTypeVariable, +} + +// AttributeSchemaMemoryType specifies the a value schema_memory_type attribute. +type AttributeSchemaMemoryType int + +const ( + _ AttributeSchemaMemoryType = iota + AttributeSchemaMemoryTypeMain + AttributeSchemaMemoryTypeDelta + AttributeSchemaMemoryTypeHistoryMain + AttributeSchemaMemoryTypeHistoryDelta +) + +// String returns the string representation of the AttributeSchemaMemoryType. +func (av AttributeSchemaMemoryType) String() string { + switch av { + case AttributeSchemaMemoryTypeMain: + return "main" + case AttributeSchemaMemoryTypeDelta: + return "delta" + case AttributeSchemaMemoryTypeHistoryMain: + return "history_main" + case AttributeSchemaMemoryTypeHistoryDelta: + return "history_delta" + } + return "" +} + +// MapAttributeSchemaMemoryType is a helper map of string to AttributeSchemaMemoryType attribute value. +var MapAttributeSchemaMemoryType = map[string]AttributeSchemaMemoryType{ + "main": AttributeSchemaMemoryTypeMain, + "delta": AttributeSchemaMemoryTypeDelta, + "history_main": AttributeSchemaMemoryTypeHistoryMain, + "history_delta": AttributeSchemaMemoryTypeHistoryDelta, +} + +// AttributeSchemaOperationType specifies the a value schema_operation_type attribute. +type AttributeSchemaOperationType int + +const ( + _ AttributeSchemaOperationType = iota + AttributeSchemaOperationTypeRead + AttributeSchemaOperationTypeWrite + AttributeSchemaOperationTypeMerge +) + +// String returns the string representation of the AttributeSchemaOperationType. +func (av AttributeSchemaOperationType) String() string { + switch av { + case AttributeSchemaOperationTypeRead: + return "read" + case AttributeSchemaOperationTypeWrite: + return "write" + case AttributeSchemaOperationTypeMerge: + return "merge" + } + return "" +} + +// MapAttributeSchemaOperationType is a helper map of string to AttributeSchemaOperationType attribute value. +var MapAttributeSchemaOperationType = map[string]AttributeSchemaOperationType{ + "read": AttributeSchemaOperationTypeRead, + "write": AttributeSchemaOperationTypeWrite, + "merge": AttributeSchemaOperationTypeMerge, +} + +// AttributeSchemaRecordType specifies the a value schema_record_type attribute. +type AttributeSchemaRecordType int + +const ( + _ AttributeSchemaRecordType = iota + AttributeSchemaRecordTypeMain + AttributeSchemaRecordTypeDelta + AttributeSchemaRecordTypeHistoryMain + AttributeSchemaRecordTypeHistoryDelta +) + +// String returns the string representation of the AttributeSchemaRecordType. +func (av AttributeSchemaRecordType) String() string { + switch av { + case AttributeSchemaRecordTypeMain: + return "main" + case AttributeSchemaRecordTypeDelta: + return "delta" + case AttributeSchemaRecordTypeHistoryMain: + return "history_main" + case AttributeSchemaRecordTypeHistoryDelta: + return "history_delta" + } + return "" +} + +// MapAttributeSchemaRecordType is a helper map of string to AttributeSchemaRecordType attribute value. +var MapAttributeSchemaRecordType = map[string]AttributeSchemaRecordType{ + "main": AttributeSchemaRecordTypeMain, + "delta": AttributeSchemaRecordTypeDelta, + "history_main": AttributeSchemaRecordTypeHistoryMain, + "history_delta": AttributeSchemaRecordTypeHistoryDelta, +} + +// AttributeServiceMemoryUsedType specifies the a value service_memory_used_type attribute. +type AttributeServiceMemoryUsedType int + +const ( + _ AttributeServiceMemoryUsedType = iota + AttributeServiceMemoryUsedTypeLogical + AttributeServiceMemoryUsedTypePhysical +) + +// String returns the string representation of the AttributeServiceMemoryUsedType. +func (av AttributeServiceMemoryUsedType) String() string { + switch av { + case AttributeServiceMemoryUsedTypeLogical: + return "logical" + case AttributeServiceMemoryUsedTypePhysical: + return "physical" + } + return "" +} + +// MapAttributeServiceMemoryUsedType is a helper map of string to AttributeServiceMemoryUsedType attribute value. +var MapAttributeServiceMemoryUsedType = map[string]AttributeServiceMemoryUsedType{ + "logical": AttributeServiceMemoryUsedTypeLogical, + "physical": AttributeServiceMemoryUsedTypePhysical, +} + +// AttributeServiceStatus specifies the a value service_status attribute. +type AttributeServiceStatus int + +const ( + _ AttributeServiceStatus = iota + AttributeServiceStatusActive + AttributeServiceStatusInactive +) + +// String returns the string representation of the AttributeServiceStatus. +func (av AttributeServiceStatus) String() string { + switch av { + case AttributeServiceStatusActive: + return "active" + case AttributeServiceStatusInactive: + return "inactive" + } + return "" +} + +// MapAttributeServiceStatus is a helper map of string to AttributeServiceStatus attribute value. +var MapAttributeServiceStatus = map[string]AttributeServiceStatus{ + "active": AttributeServiceStatusActive, + "inactive": AttributeServiceStatusInactive, +} + +// AttributeThreadStatus specifies the a value thread_status attribute. +type AttributeThreadStatus int + +const ( + _ AttributeThreadStatus = iota + AttributeThreadStatusActive + AttributeThreadStatusInactive +) + +// String returns the string representation of the AttributeThreadStatus. +func (av AttributeThreadStatus) String() string { + switch av { + case AttributeThreadStatusActive: + return "active" + case AttributeThreadStatusInactive: + return "inactive" + } + return "" +} + +// MapAttributeThreadStatus is a helper map of string to AttributeThreadStatus attribute value. +var MapAttributeThreadStatus = map[string]AttributeThreadStatus{ + "active": AttributeThreadStatusActive, + "inactive": AttributeThreadStatusInactive, +} + +// AttributeTransactionType specifies the a value transaction_type attribute. +type AttributeTransactionType int + +const ( + _ AttributeTransactionType = iota + AttributeTransactionTypeUpdate + AttributeTransactionTypeCommit + AttributeTransactionTypeRollback +) + +// String returns the string representation of the AttributeTransactionType. +func (av AttributeTransactionType) String() string { + switch av { + case AttributeTransactionTypeUpdate: + return "update" + case AttributeTransactionTypeCommit: + return "commit" + case AttributeTransactionTypeRollback: + return "rollback" + } + return "" +} + +// MapAttributeTransactionType is a helper map of string to AttributeTransactionType attribute value. +var MapAttributeTransactionType = map[string]AttributeTransactionType{ + "update": AttributeTransactionTypeUpdate, + "commit": AttributeTransactionTypeCommit, + "rollback": AttributeTransactionTypeRollback, +} + +// AttributeVolumeOperationType specifies the a value volume_operation_type attribute. +type AttributeVolumeOperationType int + +const ( + _ AttributeVolumeOperationType = iota + AttributeVolumeOperationTypeRead + AttributeVolumeOperationTypeWrite +) + +// String returns the string representation of the AttributeVolumeOperationType. +func (av AttributeVolumeOperationType) String() string { + switch av { + case AttributeVolumeOperationTypeRead: + return "read" + case AttributeVolumeOperationTypeWrite: + return "write" + } + return "" +} + +// MapAttributeVolumeOperationType is a helper map of string to AttributeVolumeOperationType attribute value. +var MapAttributeVolumeOperationType = map[string]AttributeVolumeOperationType{ + "read": AttributeVolumeOperationTypeRead, + "write": AttributeVolumeOperationTypeWrite, +} + type metricSaphanaAlertCount struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -2840,11 +3352,11 @@ func (mb *MetricsBuilder) RecordSaphanaBackupLatestDataPoint(ts pcommon.Timestam } // RecordSaphanaColumnMemoryUsedDataPoint adds a data point to saphana.column.memory.used metric. -func (mb *MetricsBuilder) RecordSaphanaColumnMemoryUsedDataPoint(ts pcommon.Timestamp, val string, columnMemoryTypeAttributeValue string, columnMemorySubtypeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaColumnMemoryUsedDataPoint(ts pcommon.Timestamp, val string, columnMemoryTypeAttributeValue AttributeColumnMemoryType, columnMemorySubtypeAttributeValue AttributeColumnMemorySubtype) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaColumnMemoryUsed, value was %s: %w", val, err) } else { - mb.metricSaphanaColumnMemoryUsed.recordDataPoint(mb.startTime, ts, i, columnMemoryTypeAttributeValue, columnMemorySubtypeAttributeValue) + mb.metricSaphanaColumnMemoryUsed.recordDataPoint(mb.startTime, ts, i, columnMemoryTypeAttributeValue.String(), columnMemorySubtypeAttributeValue.String()) } return nil } @@ -2860,51 +3372,51 @@ func (mb *MetricsBuilder) RecordSaphanaComponentMemoryUsedDataPoint(ts pcommon.T } // RecordSaphanaConnectionCountDataPoint adds a data point to saphana.connection.count metric. -func (mb *MetricsBuilder) RecordSaphanaConnectionCountDataPoint(ts pcommon.Timestamp, val string, connectionStatusAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaConnectionCountDataPoint(ts pcommon.Timestamp, val string, connectionStatusAttributeValue AttributeConnectionStatus) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaConnectionCount, value was %s: %w", val, err) } else { - mb.metricSaphanaConnectionCount.recordDataPoint(mb.startTime, ts, i, connectionStatusAttributeValue) + mb.metricSaphanaConnectionCount.recordDataPoint(mb.startTime, ts, i, connectionStatusAttributeValue.String()) } return nil } // RecordSaphanaCPUUsedDataPoint adds a data point to saphana.cpu.used metric. -func (mb *MetricsBuilder) RecordSaphanaCPUUsedDataPoint(ts pcommon.Timestamp, val string, cpuTypeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaCPUUsedDataPoint(ts pcommon.Timestamp, val string, cpuTypeAttributeValue AttributeCPUType) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaCPUUsed, value was %s: %w", val, err) } else { - mb.metricSaphanaCPUUsed.recordDataPoint(mb.startTime, ts, i, cpuTypeAttributeValue) + mb.metricSaphanaCPUUsed.recordDataPoint(mb.startTime, ts, i, cpuTypeAttributeValue.String()) } return nil } // RecordSaphanaDiskSizeCurrentDataPoint adds a data point to saphana.disk.size.current metric. -func (mb *MetricsBuilder) RecordSaphanaDiskSizeCurrentDataPoint(ts pcommon.Timestamp, val string, pathAttributeValue string, diskUsageTypeAttributeValue string, diskStateUsedFreeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaDiskSizeCurrentDataPoint(ts pcommon.Timestamp, val string, pathAttributeValue string, diskUsageTypeAttributeValue string, diskStateUsedFreeAttributeValue AttributeDiskStateUsedFree) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaDiskSizeCurrent, value was %s: %w", val, err) } else { - mb.metricSaphanaDiskSizeCurrent.recordDataPoint(mb.startTime, ts, i, pathAttributeValue, diskUsageTypeAttributeValue, diskStateUsedFreeAttributeValue) + mb.metricSaphanaDiskSizeCurrent.recordDataPoint(mb.startTime, ts, i, pathAttributeValue, diskUsageTypeAttributeValue, diskStateUsedFreeAttributeValue.String()) } return nil } // RecordSaphanaHostMemoryCurrentDataPoint adds a data point to saphana.host.memory.current metric. -func (mb *MetricsBuilder) RecordSaphanaHostMemoryCurrentDataPoint(ts pcommon.Timestamp, val string, memoryStateUsedFreeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaHostMemoryCurrentDataPoint(ts pcommon.Timestamp, val string, memoryStateUsedFreeAttributeValue AttributeMemoryStateUsedFree) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaHostMemoryCurrent, value was %s: %w", val, err) } else { - mb.metricSaphanaHostMemoryCurrent.recordDataPoint(mb.startTime, ts, i, memoryStateUsedFreeAttributeValue) + mb.metricSaphanaHostMemoryCurrent.recordDataPoint(mb.startTime, ts, i, memoryStateUsedFreeAttributeValue.String()) } return nil } // RecordSaphanaHostSwapCurrentDataPoint adds a data point to saphana.host.swap.current metric. -func (mb *MetricsBuilder) RecordSaphanaHostSwapCurrentDataPoint(ts pcommon.Timestamp, val string, hostSwapStateAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaHostSwapCurrentDataPoint(ts pcommon.Timestamp, val string, hostSwapStateAttributeValue AttributeHostSwapState) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaHostSwapCurrent, value was %s: %w", val, err) } else { - mb.metricSaphanaHostSwapCurrent.recordDataPoint(mb.startTime, ts, i, hostSwapStateAttributeValue) + mb.metricSaphanaHostSwapCurrent.recordDataPoint(mb.startTime, ts, i, hostSwapStateAttributeValue.String()) } return nil } @@ -2920,11 +3432,11 @@ func (mb *MetricsBuilder) RecordSaphanaInstanceCodeSizeDataPoint(ts pcommon.Time } // RecordSaphanaInstanceMemoryCurrentDataPoint adds a data point to saphana.instance.memory.current metric. -func (mb *MetricsBuilder) RecordSaphanaInstanceMemoryCurrentDataPoint(ts pcommon.Timestamp, val string, memoryStateUsedFreeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaInstanceMemoryCurrentDataPoint(ts pcommon.Timestamp, val string, memoryStateUsedFreeAttributeValue AttributeMemoryStateUsedFree) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaInstanceMemoryCurrent, value was %s: %w", val, err) } else { - mb.metricSaphanaInstanceMemoryCurrent.recordDataPoint(mb.startTime, ts, i, memoryStateUsedFreeAttributeValue) + mb.metricSaphanaInstanceMemoryCurrent.recordDataPoint(mb.startTime, ts, i, memoryStateUsedFreeAttributeValue.String()) } return nil } @@ -2990,21 +3502,21 @@ func (mb *MetricsBuilder) RecordSaphanaNetworkRequestAverageTimeDataPoint(ts pco } // RecordSaphanaNetworkRequestCountDataPoint adds a data point to saphana.network.request.count metric. -func (mb *MetricsBuilder) RecordSaphanaNetworkRequestCountDataPoint(ts pcommon.Timestamp, val string, activePendingRequestStateAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaNetworkRequestCountDataPoint(ts pcommon.Timestamp, val string, activePendingRequestStateAttributeValue AttributeActivePendingRequestState) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaNetworkRequestCount, value was %s: %w", val, err) } else { - mb.metricSaphanaNetworkRequestCount.recordDataPoint(mb.startTime, ts, i, activePendingRequestStateAttributeValue) + mb.metricSaphanaNetworkRequestCount.recordDataPoint(mb.startTime, ts, i, activePendingRequestStateAttributeValue.String()) } return nil } // RecordSaphanaNetworkRequestFinishedCountDataPoint adds a data point to saphana.network.request.finished.count metric. -func (mb *MetricsBuilder) RecordSaphanaNetworkRequestFinishedCountDataPoint(ts pcommon.Timestamp, val string, internalExternalRequestTypeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaNetworkRequestFinishedCountDataPoint(ts pcommon.Timestamp, val string, internalExternalRequestTypeAttributeValue AttributeInternalExternalRequestType) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaNetworkRequestFinishedCount, value was %s: %w", val, err) } else { - mb.metricSaphanaNetworkRequestFinishedCount.recordDataPoint(mb.startTime, ts, i, internalExternalRequestTypeAttributeValue) + mb.metricSaphanaNetworkRequestFinishedCount.recordDataPoint(mb.startTime, ts, i, internalExternalRequestTypeAttributeValue.String()) } return nil } @@ -3040,21 +3552,21 @@ func (mb *MetricsBuilder) RecordSaphanaReplicationBacklogTimeDataPoint(ts pcommo } // RecordSaphanaRowStoreMemoryUsedDataPoint adds a data point to saphana.row_store.memory.used metric. -func (mb *MetricsBuilder) RecordSaphanaRowStoreMemoryUsedDataPoint(ts pcommon.Timestamp, val string, rowMemoryTypeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaRowStoreMemoryUsedDataPoint(ts pcommon.Timestamp, val string, rowMemoryTypeAttributeValue AttributeRowMemoryType) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaRowStoreMemoryUsed, value was %s: %w", val, err) } else { - mb.metricSaphanaRowStoreMemoryUsed.recordDataPoint(mb.startTime, ts, i, rowMemoryTypeAttributeValue) + mb.metricSaphanaRowStoreMemoryUsed.recordDataPoint(mb.startTime, ts, i, rowMemoryTypeAttributeValue.String()) } return nil } // RecordSaphanaSchemaMemoryUsedCurrentDataPoint adds a data point to saphana.schema.memory.used.current metric. -func (mb *MetricsBuilder) RecordSaphanaSchemaMemoryUsedCurrentDataPoint(ts pcommon.Timestamp, val string, schemaAttributeValue string, schemaMemoryTypeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaSchemaMemoryUsedCurrentDataPoint(ts pcommon.Timestamp, val string, schemaAttributeValue string, schemaMemoryTypeAttributeValue AttributeSchemaMemoryType) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaSchemaMemoryUsedCurrent, value was %s: %w", val, err) } else { - mb.metricSaphanaSchemaMemoryUsedCurrent.recordDataPoint(mb.startTime, ts, i, schemaAttributeValue, schemaMemoryTypeAttributeValue) + mb.metricSaphanaSchemaMemoryUsedCurrent.recordDataPoint(mb.startTime, ts, i, schemaAttributeValue, schemaMemoryTypeAttributeValue.String()) } return nil } @@ -3070,11 +3582,11 @@ func (mb *MetricsBuilder) RecordSaphanaSchemaMemoryUsedMaxDataPoint(ts pcommon.T } // RecordSaphanaSchemaOperationCountDataPoint adds a data point to saphana.schema.operation.count metric. -func (mb *MetricsBuilder) RecordSaphanaSchemaOperationCountDataPoint(ts pcommon.Timestamp, val string, schemaAttributeValue string, schemaOperationTypeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaSchemaOperationCountDataPoint(ts pcommon.Timestamp, val string, schemaAttributeValue string, schemaOperationTypeAttributeValue AttributeSchemaOperationType) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaSchemaOperationCount, value was %s: %w", val, err) } else { - mb.metricSaphanaSchemaOperationCount.recordDataPoint(mb.startTime, ts, i, schemaAttributeValue, schemaOperationTypeAttributeValue) + mb.metricSaphanaSchemaOperationCount.recordDataPoint(mb.startTime, ts, i, schemaAttributeValue, schemaOperationTypeAttributeValue.String()) } return nil } @@ -3090,11 +3602,11 @@ func (mb *MetricsBuilder) RecordSaphanaSchemaRecordCompressedCountDataPoint(ts p } // RecordSaphanaSchemaRecordCountDataPoint adds a data point to saphana.schema.record.count metric. -func (mb *MetricsBuilder) RecordSaphanaSchemaRecordCountDataPoint(ts pcommon.Timestamp, val string, schemaAttributeValue string, schemaRecordTypeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaSchemaRecordCountDataPoint(ts pcommon.Timestamp, val string, schemaAttributeValue string, schemaRecordTypeAttributeValue AttributeSchemaRecordType) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaSchemaRecordCount, value was %s: %w", val, err) } else { - mb.metricSaphanaSchemaRecordCount.recordDataPoint(mb.startTime, ts, i, schemaAttributeValue, schemaRecordTypeAttributeValue) + mb.metricSaphanaSchemaRecordCount.recordDataPoint(mb.startTime, ts, i, schemaAttributeValue, schemaRecordTypeAttributeValue.String()) } return nil } @@ -3110,11 +3622,11 @@ func (mb *MetricsBuilder) RecordSaphanaServiceCodeSizeDataPoint(ts pcommon.Times } // RecordSaphanaServiceCountDataPoint adds a data point to saphana.service.count metric. -func (mb *MetricsBuilder) RecordSaphanaServiceCountDataPoint(ts pcommon.Timestamp, val string, serviceStatusAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaServiceCountDataPoint(ts pcommon.Timestamp, val string, serviceStatusAttributeValue AttributeServiceStatus) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaServiceCount, value was %s: %w", val, err) } else { - mb.metricSaphanaServiceCount.recordDataPoint(mb.startTime, ts, i, serviceStatusAttributeValue) + mb.metricSaphanaServiceCount.recordDataPoint(mb.startTime, ts, i, serviceStatusAttributeValue.String()) } return nil } @@ -3150,11 +3662,11 @@ func (mb *MetricsBuilder) RecordSaphanaServiceMemoryEffectiveLimitDataPoint(ts p } // RecordSaphanaServiceMemoryHeapCurrentDataPoint adds a data point to saphana.service.memory.heap.current metric. -func (mb *MetricsBuilder) RecordSaphanaServiceMemoryHeapCurrentDataPoint(ts pcommon.Timestamp, val string, serviceAttributeValue string, memoryStateUsedFreeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaServiceMemoryHeapCurrentDataPoint(ts pcommon.Timestamp, val string, serviceAttributeValue string, memoryStateUsedFreeAttributeValue AttributeMemoryStateUsedFree) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaServiceMemoryHeapCurrent, value was %s: %w", val, err) } else { - mb.metricSaphanaServiceMemoryHeapCurrent.recordDataPoint(mb.startTime, ts, i, serviceAttributeValue, memoryStateUsedFreeAttributeValue) + mb.metricSaphanaServiceMemoryHeapCurrent.recordDataPoint(mb.startTime, ts, i, serviceAttributeValue, memoryStateUsedFreeAttributeValue.String()) } return nil } @@ -3170,21 +3682,21 @@ func (mb *MetricsBuilder) RecordSaphanaServiceMemoryLimitDataPoint(ts pcommon.Ti } // RecordSaphanaServiceMemorySharedCurrentDataPoint adds a data point to saphana.service.memory.shared.current metric. -func (mb *MetricsBuilder) RecordSaphanaServiceMemorySharedCurrentDataPoint(ts pcommon.Timestamp, val string, serviceAttributeValue string, memoryStateUsedFreeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaServiceMemorySharedCurrentDataPoint(ts pcommon.Timestamp, val string, serviceAttributeValue string, memoryStateUsedFreeAttributeValue AttributeMemoryStateUsedFree) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaServiceMemorySharedCurrent, value was %s: %w", val, err) } else { - mb.metricSaphanaServiceMemorySharedCurrent.recordDataPoint(mb.startTime, ts, i, serviceAttributeValue, memoryStateUsedFreeAttributeValue) + mb.metricSaphanaServiceMemorySharedCurrent.recordDataPoint(mb.startTime, ts, i, serviceAttributeValue, memoryStateUsedFreeAttributeValue.String()) } return nil } // RecordSaphanaServiceMemoryUsedDataPoint adds a data point to saphana.service.memory.used metric. -func (mb *MetricsBuilder) RecordSaphanaServiceMemoryUsedDataPoint(ts pcommon.Timestamp, val string, serviceAttributeValue string, serviceMemoryUsedTypeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaServiceMemoryUsedDataPoint(ts pcommon.Timestamp, val string, serviceAttributeValue string, serviceMemoryUsedTypeAttributeValue AttributeServiceMemoryUsedType) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaServiceMemoryUsed, value was %s: %w", val, err) } else { - mb.metricSaphanaServiceMemoryUsed.recordDataPoint(mb.startTime, ts, i, serviceAttributeValue, serviceMemoryUsedTypeAttributeValue) + mb.metricSaphanaServiceMemoryUsed.recordDataPoint(mb.startTime, ts, i, serviceAttributeValue, serviceMemoryUsedTypeAttributeValue.String()) } return nil } @@ -3200,11 +3712,11 @@ func (mb *MetricsBuilder) RecordSaphanaServiceStackSizeDataPoint(ts pcommon.Time } // RecordSaphanaServiceThreadCountDataPoint adds a data point to saphana.service.thread.count metric. -func (mb *MetricsBuilder) RecordSaphanaServiceThreadCountDataPoint(ts pcommon.Timestamp, val string, threadStatusAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaServiceThreadCountDataPoint(ts pcommon.Timestamp, val string, threadStatusAttributeValue AttributeThreadStatus) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaServiceThreadCount, value was %s: %w", val, err) } else { - mb.metricSaphanaServiceThreadCount.recordDataPoint(mb.startTime, ts, i, threadStatusAttributeValue) + mb.metricSaphanaServiceThreadCount.recordDataPoint(mb.startTime, ts, i, threadStatusAttributeValue.String()) } return nil } @@ -3220,11 +3732,11 @@ func (mb *MetricsBuilder) RecordSaphanaTransactionBlockedDataPoint(ts pcommon.Ti } // RecordSaphanaTransactionCountDataPoint adds a data point to saphana.transaction.count metric. -func (mb *MetricsBuilder) RecordSaphanaTransactionCountDataPoint(ts pcommon.Timestamp, val string, transactionTypeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaTransactionCountDataPoint(ts pcommon.Timestamp, val string, transactionTypeAttributeValue AttributeTransactionType) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaTransactionCount, value was %s: %w", val, err) } else { - mb.metricSaphanaTransactionCount.recordDataPoint(mb.startTime, ts, i, transactionTypeAttributeValue) + mb.metricSaphanaTransactionCount.recordDataPoint(mb.startTime, ts, i, transactionTypeAttributeValue.String()) } return nil } @@ -3240,31 +3752,31 @@ func (mb *MetricsBuilder) RecordSaphanaUptimeDataPoint(ts pcommon.Timestamp, val } // RecordSaphanaVolumeOperationCountDataPoint adds a data point to saphana.volume.operation.count metric. -func (mb *MetricsBuilder) RecordSaphanaVolumeOperationCountDataPoint(ts pcommon.Timestamp, val string, pathAttributeValue string, diskUsageTypeAttributeValue string, volumeOperationTypeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaVolumeOperationCountDataPoint(ts pcommon.Timestamp, val string, pathAttributeValue string, diskUsageTypeAttributeValue string, volumeOperationTypeAttributeValue AttributeVolumeOperationType) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaVolumeOperationCount, value was %s: %w", val, err) } else { - mb.metricSaphanaVolumeOperationCount.recordDataPoint(mb.startTime, ts, i, pathAttributeValue, diskUsageTypeAttributeValue, volumeOperationTypeAttributeValue) + mb.metricSaphanaVolumeOperationCount.recordDataPoint(mb.startTime, ts, i, pathAttributeValue, diskUsageTypeAttributeValue, volumeOperationTypeAttributeValue.String()) } return nil } // RecordSaphanaVolumeOperationSizeDataPoint adds a data point to saphana.volume.operation.size metric. -func (mb *MetricsBuilder) RecordSaphanaVolumeOperationSizeDataPoint(ts pcommon.Timestamp, val string, pathAttributeValue string, diskUsageTypeAttributeValue string, volumeOperationTypeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaVolumeOperationSizeDataPoint(ts pcommon.Timestamp, val string, pathAttributeValue string, diskUsageTypeAttributeValue string, volumeOperationTypeAttributeValue AttributeVolumeOperationType) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaVolumeOperationSize, value was %s: %w", val, err) } else { - mb.metricSaphanaVolumeOperationSize.recordDataPoint(mb.startTime, ts, i, pathAttributeValue, diskUsageTypeAttributeValue, volumeOperationTypeAttributeValue) + mb.metricSaphanaVolumeOperationSize.recordDataPoint(mb.startTime, ts, i, pathAttributeValue, diskUsageTypeAttributeValue, volumeOperationTypeAttributeValue.String()) } return nil } // RecordSaphanaVolumeOperationTimeDataPoint adds a data point to saphana.volume.operation.time metric. -func (mb *MetricsBuilder) RecordSaphanaVolumeOperationTimeDataPoint(ts pcommon.Timestamp, val string, pathAttributeValue string, diskUsageTypeAttributeValue string, volumeOperationTypeAttributeValue string) error { +func (mb *MetricsBuilder) RecordSaphanaVolumeOperationTimeDataPoint(ts pcommon.Timestamp, val string, pathAttributeValue string, diskUsageTypeAttributeValue string, volumeOperationTypeAttributeValue AttributeVolumeOperationType) error { if i, err := strconv.ParseInt(val, 10, 64); err != nil { return fmt.Errorf("failed to parse int for SaphanaVolumeOperationTime, value was %s: %w", val, err) } else { - mb.metricSaphanaVolumeOperationTime.recordDataPoint(mb.startTime, ts, i, pathAttributeValue, diskUsageTypeAttributeValue, volumeOperationTypeAttributeValue) + mb.metricSaphanaVolumeOperationTime.recordDataPoint(mb.startTime, ts, i, pathAttributeValue, diskUsageTypeAttributeValue, volumeOperationTypeAttributeValue.String()) } return nil } @@ -3378,187 +3890,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeActivePendingRequestState are the possible values that the attribute "active_pending_request_state" can have. -var AttributeActivePendingRequestState = struct { - Active string - Pending string -}{ - "active", - "pending", -} - -// AttributeColumnMemorySubtype are the possible values that the attribute "column_memory_subtype" can have. -var AttributeColumnMemorySubtype = struct { - Data string - Dict string - Index string - Misc string -}{ - "data", - "dict", - "index", - "misc", -} - -// AttributeColumnMemoryType are the possible values that the attribute "column_memory_type" can have. -var AttributeColumnMemoryType = struct { - Main string - Delta string -}{ - "main", - "delta", -} - -// AttributeConnectionStatus are the possible values that the attribute "connection_status" can have. -var AttributeConnectionStatus = struct { - Running string - Idle string - Queueing string -}{ - "running", - "idle", - "queueing", -} - -// AttributeCPUType are the possible values that the attribute "cpu_type" can have. -var AttributeCPUType = struct { - User string - System string - IoWait string - Idle string -}{ - "user", - "system", - "io_wait", - "idle", -} - -// AttributeDiskStateUsedFree are the possible values that the attribute "disk_state_used_free" can have. -var AttributeDiskStateUsedFree = struct { - Used string - Free string -}{ - "used", - "free", -} - -// AttributeHostSwapState are the possible values that the attribute "host_swap_state" can have. -var AttributeHostSwapState = struct { - Used string - Free string -}{ - "used", - "free", -} - -// AttributeInternalExternalRequestType are the possible values that the attribute "internal_external_request_type" can have. -var AttributeInternalExternalRequestType = struct { - Internal string - External string -}{ - "internal", - "external", -} - -// AttributeMemoryStateUsedFree are the possible values that the attribute "memory_state_used_free" can have. -var AttributeMemoryStateUsedFree = struct { - Used string - Free string -}{ - "used", - "free", -} - -// AttributeRowMemoryType are the possible values that the attribute "row_memory_type" can have. -var AttributeRowMemoryType = struct { - Fixed string - Variable string -}{ - "fixed", - "variable", -} - -// AttributeSchemaMemoryType are the possible values that the attribute "schema_memory_type" can have. -var AttributeSchemaMemoryType = struct { - Main string - Delta string - HistoryMain string - HistoryDelta string -}{ - "main", - "delta", - "history_main", - "history_delta", -} - -// AttributeSchemaOperationType are the possible values that the attribute "schema_operation_type" can have. -var AttributeSchemaOperationType = struct { - Read string - Write string - Merge string -}{ - "read", - "write", - "merge", -} - -// AttributeSchemaRecordType are the possible values that the attribute "schema_record_type" can have. -var AttributeSchemaRecordType = struct { - Main string - Delta string - HistoryMain string - HistoryDelta string -}{ - "main", - "delta", - "history_main", - "history_delta", -} - -// AttributeServiceMemoryUsedType are the possible values that the attribute "service_memory_used_type" can have. -var AttributeServiceMemoryUsedType = struct { - Logical string - Physical string -}{ - "logical", - "physical", -} - -// AttributeServiceStatus are the possible values that the attribute "service_status" can have. -var AttributeServiceStatus = struct { - Active string - Inactive string -}{ - "active", - "inactive", -} - -// AttributeThreadStatus are the possible values that the attribute "thread_status" can have. -var AttributeThreadStatus = struct { - Active string - Inactive string -}{ - "active", - "inactive", -} - -// AttributeTransactionType are the possible values that the attribute "transaction_type" can have. -var AttributeTransactionType = struct { - Update string - Commit string - Rollback string -}{ - "update", - "commit", - "rollback", -} - -// AttributeVolumeOperationType are the possible values that the attribute "volume_operation_type" can have. -var AttributeVolumeOperationType = struct { - Read string - Write string -}{ - "read", - "write", -} diff --git a/receiver/saphanareceiver/queries.go b/receiver/saphanareceiver/queries.go index 3efef470e51f..76b7d4cdc17a 100644 --- a/receiver/saphanareceiver/queries.go +++ b/receiver/saphanareceiver/queries.go @@ -73,14 +73,14 @@ var queries = []monitoringQuery{ key: "active_services", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaServiceCountDataPoint(now, val, metadata.AttributeServiceStatus.Active) + mb.RecordSaphanaServiceCountDataPoint(now, val, metadata.AttributeServiceStatusActive) }, }, { key: "inactive_services", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaServiceCountDataPoint(now, val, metadata.AttributeServiceStatus.Inactive) + mb.RecordSaphanaServiceCountDataPoint(now, val, metadata.AttributeServiceStatusInactive) }, }, }, @@ -96,14 +96,14 @@ var queries = []monitoringQuery{ key: "active_threads", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaServiceThreadCountDataPoint(now, val, metadata.AttributeThreadStatus.Active) + mb.RecordSaphanaServiceThreadCountDataPoint(now, val, metadata.AttributeThreadStatusActive) }, }, { key: "inactive_threads", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaServiceThreadCountDataPoint(now, val, metadata.AttributeThreadStatus.Inactive) + mb.RecordSaphanaServiceThreadCountDataPoint(now, val, metadata.AttributeThreadStatusInactive) }, }, }, @@ -119,56 +119,56 @@ var queries = []monitoringQuery{ key: "main_data", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryType.Main, metadata.AttributeColumnMemorySubtype.Data) + mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryTypeMain, metadata.AttributeColumnMemorySubtypeData) }, }, { key: "main_dict", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryType.Main, metadata.AttributeColumnMemorySubtype.Dict) + mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryTypeMain, metadata.AttributeColumnMemorySubtypeDict) }, }, { key: "main_index", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryType.Main, metadata.AttributeColumnMemorySubtype.Index) + mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryTypeMain, metadata.AttributeColumnMemorySubtypeIndex) }, }, { key: "main_misc", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryType.Main, metadata.AttributeColumnMemorySubtype.Misc) + mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryTypeMain, metadata.AttributeColumnMemorySubtypeMisc) }, }, { key: "delta_data", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryType.Delta, metadata.AttributeColumnMemorySubtype.Data) + mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryTypeDelta, metadata.AttributeColumnMemorySubtypeData) }, }, { key: "delta_dict", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryType.Delta, metadata.AttributeColumnMemorySubtype.Dict) + mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryTypeDelta, metadata.AttributeColumnMemorySubtypeDict) }, }, { key: "delta_index", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryType.Delta, metadata.AttributeColumnMemorySubtype.Index) + mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryTypeDelta, metadata.AttributeColumnMemorySubtypeIndex) }, }, { key: "delta_misc", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryType.Delta, metadata.AttributeColumnMemorySubtype.Misc) + mb.RecordSaphanaColumnMemoryUsedDataPoint(now, val, metadata.AttributeColumnMemoryTypeDelta, metadata.AttributeColumnMemorySubtypeMisc) }, }, }, @@ -184,14 +184,14 @@ var queries = []monitoringQuery{ key: "fixed", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaRowStoreMemoryUsedDataPoint(now, val, metadata.AttributeRowMemoryType.Fixed) + mb.RecordSaphanaRowStoreMemoryUsedDataPoint(now, val, metadata.AttributeRowMemoryTypeFixed) }, }, { key: "variable", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaRowStoreMemoryUsedDataPoint(now, val, metadata.AttributeRowMemoryType.Variable) + mb.RecordSaphanaRowStoreMemoryUsedDataPoint(now, val, metadata.AttributeRowMemoryTypeVariable) }, }, }, @@ -224,7 +224,8 @@ var queries = []monitoringQuery{ key: "connections", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaConnectionCountDataPoint(now, val, strings.ToLower(row["connection_status"])) + mb.RecordSaphanaConnectionCountDataPoint(now, val, + metadata.MapAttributeConnectionStatus[strings.ToLower(row["connection_status"])]) }, }, }, @@ -289,21 +290,21 @@ var queries = []monitoringQuery{ key: "updates", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaTransactionCountDataPoint(now, val, metadata.AttributeTransactionType.Update) + mb.RecordSaphanaTransactionCountDataPoint(now, val, metadata.AttributeTransactionTypeUpdate) }, }, { key: "commits", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaTransactionCountDataPoint(now, val, metadata.AttributeTransactionType.Commit) + mb.RecordSaphanaTransactionCountDataPoint(now, val, metadata.AttributeTransactionTypeCommit) }, }, { key: "rollbacks", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaTransactionCountDataPoint(now, val, metadata.AttributeTransactionType.Rollback) + mb.RecordSaphanaTransactionCountDataPoint(now, val, metadata.AttributeTransactionTypeRollback) }, }, }, @@ -336,14 +337,14 @@ var queries = []monitoringQuery{ key: "free_size", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaDiskSizeCurrentDataPoint(now, val, row["path"], row["usage_type"], metadata.AttributeDiskStateUsedFree.Free) + mb.RecordSaphanaDiskSizeCurrentDataPoint(now, val, row["path"], row["usage_type"], metadata.AttributeDiskStateUsedFreeFree) }, }, { key: "used_size", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaDiskSizeCurrentDataPoint(now, val, row["path"], row["usage_type"], metadata.AttributeDiskStateUsedFree.Used) + mb.RecordSaphanaDiskSizeCurrentDataPoint(now, val, row["path"], row["usage_type"], metadata.AttributeDiskStateUsedFreeUsed) }, }, }, @@ -423,28 +424,28 @@ var queries = []monitoringQuery{ key: "external", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaNetworkRequestFinishedCountDataPoint(now, val, metadata.AttributeInternalExternalRequestType.External) + mb.RecordSaphanaNetworkRequestFinishedCountDataPoint(now, val, metadata.AttributeInternalExternalRequestTypeExternal) }, }, { key: "internal", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaNetworkRequestFinishedCountDataPoint(now, val, metadata.AttributeInternalExternalRequestType.Internal) + mb.RecordSaphanaNetworkRequestFinishedCountDataPoint(now, val, metadata.AttributeInternalExternalRequestTypeInternal) }, }, { key: "active", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaNetworkRequestCountDataPoint(now, val, metadata.AttributeActivePendingRequestState.Active) + mb.RecordSaphanaNetworkRequestCountDataPoint(now, val, metadata.AttributeActivePendingRequestStateActive) }, }, { key: "pending", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaNetworkRequestCountDataPoint(now, val, metadata.AttributeActivePendingRequestState.Pending) + mb.RecordSaphanaNetworkRequestCountDataPoint(now, val, metadata.AttributeActivePendingRequestStatePending) }, }, { @@ -470,42 +471,42 @@ var queries = []monitoringQuery{ key: "reads", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaVolumeOperationCountDataPoint(now, val, row["path"], row["type"], metadata.AttributeVolumeOperationType.Read) + mb.RecordSaphanaVolumeOperationCountDataPoint(now, val, row["path"], row["type"], metadata.AttributeVolumeOperationTypeRead) }, }, { key: "writes", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaVolumeOperationCountDataPoint(now, val, row["path"], row["type"], metadata.AttributeVolumeOperationType.Write) + mb.RecordSaphanaVolumeOperationCountDataPoint(now, val, row["path"], row["type"], metadata.AttributeVolumeOperationTypeWrite) }, }, { key: "read_size", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaVolumeOperationSizeDataPoint(now, val, row["path"], row["type"], metadata.AttributeVolumeOperationType.Read) + mb.RecordSaphanaVolumeOperationSizeDataPoint(now, val, row["path"], row["type"], metadata.AttributeVolumeOperationTypeRead) }, }, { key: "write_size", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaVolumeOperationSizeDataPoint(now, val, row["path"], row["type"], metadata.AttributeVolumeOperationType.Write) + mb.RecordSaphanaVolumeOperationSizeDataPoint(now, val, row["path"], row["type"], metadata.AttributeVolumeOperationTypeWrite) }, }, { key: "read_time", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaVolumeOperationTimeDataPoint(now, val, row["path"], row["type"], metadata.AttributeVolumeOperationType.Read) + mb.RecordSaphanaVolumeOperationTimeDataPoint(now, val, row["path"], row["type"], metadata.AttributeVolumeOperationTypeRead) }, }, { key: "write_time", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaVolumeOperationTimeDataPoint(now, val, row["path"], row["type"], metadata.AttributeVolumeOperationType.Write) + mb.RecordSaphanaVolumeOperationTimeDataPoint(now, val, row["path"], row["type"], metadata.AttributeVolumeOperationTypeWrite) }, }, }, @@ -524,14 +525,14 @@ var queries = []monitoringQuery{ key: "logical_used", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaServiceMemoryUsedDataPoint(now, val, row["service"], metadata.AttributeServiceMemoryUsedType.Logical) + mb.RecordSaphanaServiceMemoryUsedDataPoint(now, val, row["service"], metadata.AttributeServiceMemoryUsedTypeLogical) }, }, { key: "physical_used", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaServiceMemoryUsedDataPoint(now, val, row["service"], metadata.AttributeServiceMemoryUsedType.Physical) + mb.RecordSaphanaServiceMemoryUsedDataPoint(now, val, row["service"], metadata.AttributeServiceMemoryUsedTypePhysical) }, }, { @@ -552,28 +553,28 @@ var queries = []monitoringQuery{ key: "heap_free", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaServiceMemoryHeapCurrentDataPoint(now, val, row["service"], metadata.AttributeMemoryStateUsedFree.Free) + mb.RecordSaphanaServiceMemoryHeapCurrentDataPoint(now, val, row["service"], metadata.AttributeMemoryStateUsedFreeFree) }, }, { key: "heap_used", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaServiceMemoryHeapCurrentDataPoint(now, val, row["service"], metadata.AttributeMemoryStateUsedFree.Used) + mb.RecordSaphanaServiceMemoryHeapCurrentDataPoint(now, val, row["service"], metadata.AttributeMemoryStateUsedFreeUsed) }, }, { key: "shared_free", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaServiceMemorySharedCurrentDataPoint(now, val, row["service"], metadata.AttributeMemoryStateUsedFree.Free) + mb.RecordSaphanaServiceMemorySharedCurrentDataPoint(now, val, row["service"], metadata.AttributeMemoryStateUsedFreeFree) }, }, { key: "shared_used", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaServiceMemorySharedCurrentDataPoint(now, val, row["service"], metadata.AttributeMemoryStateUsedFree.Used) + mb.RecordSaphanaServiceMemorySharedCurrentDataPoint(now, val, row["service"], metadata.AttributeMemoryStateUsedFreeUsed) }, }, { @@ -640,77 +641,77 @@ var queries = []monitoringQuery{ key: "reads", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaSchemaOperationCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaOperationType.Read) + mb.RecordSaphanaSchemaOperationCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaOperationTypeRead) }, }, { key: "writes", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaSchemaOperationCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaOperationType.Write) + mb.RecordSaphanaSchemaOperationCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaOperationTypeWrite) }, }, { key: "merges", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaSchemaOperationCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaOperationType.Merge) + mb.RecordSaphanaSchemaOperationCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaOperationTypeMerge) }, }, { key: "mem_main", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaSchemaMemoryUsedCurrentDataPoint(now, val, row["schema"], metadata.AttributeSchemaMemoryType.Main) + mb.RecordSaphanaSchemaMemoryUsedCurrentDataPoint(now, val, row["schema"], metadata.AttributeSchemaMemoryTypeMain) }, }, { key: "mem_delta", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaSchemaMemoryUsedCurrentDataPoint(now, val, row["schema"], metadata.AttributeSchemaMemoryType.Delta) + mb.RecordSaphanaSchemaMemoryUsedCurrentDataPoint(now, val, row["schema"], metadata.AttributeSchemaMemoryTypeDelta) }, }, { key: "mem_history_main", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaSchemaMemoryUsedCurrentDataPoint(now, val, row["schema"], metadata.AttributeSchemaMemoryType.HistoryMain) + mb.RecordSaphanaSchemaMemoryUsedCurrentDataPoint(now, val, row["schema"], metadata.AttributeSchemaMemoryTypeHistoryMain) }, }, { key: "mem_history_delta", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaSchemaMemoryUsedCurrentDataPoint(now, val, row["schema"], metadata.AttributeSchemaMemoryType.HistoryDelta) + mb.RecordSaphanaSchemaMemoryUsedCurrentDataPoint(now, val, row["schema"], metadata.AttributeSchemaMemoryTypeHistoryDelta) }, }, { key: "records_main", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaSchemaRecordCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaRecordType.Main) + mb.RecordSaphanaSchemaRecordCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaRecordTypeMain) }, }, { key: "records_delta", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaSchemaRecordCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaRecordType.Delta) + mb.RecordSaphanaSchemaRecordCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaRecordTypeDelta) }, }, { key: "records_history_main", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaSchemaRecordCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaRecordType.HistoryMain) + mb.RecordSaphanaSchemaRecordCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaRecordTypeHistoryMain) }, }, { key: "records_history_delta", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaSchemaRecordCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaRecordType.HistoryDelta) + mb.RecordSaphanaSchemaRecordCountDataPoint(now, val, row["schema"], metadata.AttributeSchemaRecordTypeHistoryDelta) }, }, }, @@ -730,35 +731,35 @@ var queries = []monitoringQuery{ key: "free_physical_memory", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaHostMemoryCurrentDataPoint(now, val, metadata.AttributeMemoryStateUsedFree.Free) + mb.RecordSaphanaHostMemoryCurrentDataPoint(now, val, metadata.AttributeMemoryStateUsedFreeFree) }, }, { key: "used_physical_memory", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaHostMemoryCurrentDataPoint(now, val, metadata.AttributeMemoryStateUsedFree.Used) + mb.RecordSaphanaHostMemoryCurrentDataPoint(now, val, metadata.AttributeMemoryStateUsedFreeUsed) }, }, { key: "free_swap_space", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaHostSwapCurrentDataPoint(now, val, metadata.AttributeHostSwapState.Free) + mb.RecordSaphanaHostSwapCurrentDataPoint(now, val, metadata.AttributeHostSwapStateFree) }, }, { key: "used_swap_space", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaHostSwapCurrentDataPoint(now, val, metadata.AttributeHostSwapState.Used) + mb.RecordSaphanaHostSwapCurrentDataPoint(now, val, metadata.AttributeHostSwapStateUsed) }, }, { key: "instance_total_used", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaInstanceMemoryCurrentDataPoint(now, val, metadata.AttributeMemoryStateUsedFree.Used) + mb.RecordSaphanaInstanceMemoryCurrentDataPoint(now, val, metadata.AttributeMemoryStateUsedFreeUsed) }, }, { @@ -772,7 +773,7 @@ var queries = []monitoringQuery{ key: "instance_total_free", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaInstanceMemoryCurrentDataPoint(now, val, metadata.AttributeMemoryStateUsedFree.Free) + mb.RecordSaphanaInstanceMemoryCurrentDataPoint(now, val, metadata.AttributeMemoryStateUsedFreeFree) }, }, { @@ -793,28 +794,28 @@ var queries = []monitoringQuery{ key: "cpu_user", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaCPUUsedDataPoint(now, val, metadata.AttributeCPUType.User) + mb.RecordSaphanaCPUUsedDataPoint(now, val, metadata.AttributeCPUTypeUser) }, }, { key: "cpu_system", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaCPUUsedDataPoint(now, val, metadata.AttributeCPUType.System) + mb.RecordSaphanaCPUUsedDataPoint(now, val, metadata.AttributeCPUTypeSystem) }, }, { key: "cpu_io_wait", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaCPUUsedDataPoint(now, val, metadata.AttributeCPUType.IoWait) + mb.RecordSaphanaCPUUsedDataPoint(now, val, metadata.AttributeCPUTypeIoWait) }, }, { key: "cpu_idle", addMetricFunction: func(mb *metadata.MetricsBuilder, now pcommon.Timestamp, val string, row map[string]string) { - mb.RecordSaphanaCPUUsedDataPoint(now, val, metadata.AttributeCPUType.Idle) + mb.RecordSaphanaCPUUsedDataPoint(now, val, metadata.AttributeCPUTypeIdle) }, }, }, diff --git a/receiver/sqlserverreceiver/internal/metadata/generated_metrics_v2.go b/receiver/sqlserverreceiver/internal/metadata/generated_metrics_v2.go index 65b63479e7d6..35f4571a9f73 100644 --- a/receiver/sqlserverreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/sqlserverreceiver/internal/metadata/generated_metrics_v2.go @@ -103,6 +103,32 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributePageOperations specifies the a value page.operations attribute. +type AttributePageOperations int + +const ( + _ AttributePageOperations = iota + AttributePageOperationsRead + AttributePageOperationsWrite +) + +// String returns the string representation of the AttributePageOperations. +func (av AttributePageOperations) String() string { + switch av { + case AttributePageOperationsRead: + return "read" + case AttributePageOperationsWrite: + return "write" + } + return "" +} + +// MapAttributePageOperations is a helper map of string to AttributePageOperations attribute value. +var MapAttributePageOperations = map[string]AttributePageOperations{ + "read": AttributePageOperationsRead, + "write": AttributePageOperationsWrite, +} + type metricSqlserverBatchRequestRate struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -1274,8 +1300,8 @@ func (mb *MetricsBuilder) RecordSqlserverPageLifeExpectancyDataPoint(ts pcommon. } // RecordSqlserverPageOperationRateDataPoint adds a data point to sqlserver.page.operation.rate metric. -func (mb *MetricsBuilder) RecordSqlserverPageOperationRateDataPoint(ts pcommon.Timestamp, val float64, pageOperationsAttributeValue string) { - mb.metricSqlserverPageOperationRate.recordDataPoint(mb.startTime, ts, val, pageOperationsAttributeValue) +func (mb *MetricsBuilder) RecordSqlserverPageOperationRateDataPoint(ts pcommon.Timestamp, val float64, pageOperationsAttributeValue AttributePageOperations) { + mb.metricSqlserverPageOperationRate.recordDataPoint(mb.startTime, ts, val, pageOperationsAttributeValue.String()) } // RecordSqlserverPageSplitRateDataPoint adds a data point to sqlserver.page.split.rate metric. @@ -1347,12 +1373,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributePageOperations are the possible values that the attribute "page.operations" can have. -var AttributePageOperations = struct { - Read string - Write string -}{ - "read", - "write", -} diff --git a/receiver/sqlserverreceiver/internal/metadata/metrics_builder_ext.go b/receiver/sqlserverreceiver/internal/metadata/metrics_builder_ext.go index ba9bf488853c..8925dcb8a08d 100644 --- a/receiver/sqlserverreceiver/internal/metadata/metrics_builder_ext.go +++ b/receiver/sqlserverreceiver/internal/metadata/metrics_builder_ext.go @@ -41,7 +41,7 @@ func (mb *MetricsBuilder) RecordAnyDataPoint(ts pcommon.Timestamp, val float64, case "sqlserver.page.life_expectancy": mb.RecordSqlserverPageLifeExpectancyDataPoint(ts, val) case "sqlserver.page.operation.rate": - mb.RecordSqlserverPageOperationRateDataPoint(ts, val, attributes["type"]) + mb.RecordSqlserverPageOperationRateDataPoint(ts, val, MapAttributePageOperations[attributes["type"]]) case "sqlserver.page.split.rate": mb.RecordSqlserverPageSplitRateDataPoint(ts, val) case "sqlserver.transaction_log.flush.data.rate": diff --git a/receiver/zookeeperreceiver/internal/metadata/generated_metrics_v2.go b/receiver/zookeeperreceiver/internal/metadata/generated_metrics_v2.go index 0bf859755346..b6233891c58a 100644 --- a/receiver/zookeeperreceiver/internal/metadata/generated_metrics_v2.go +++ b/receiver/zookeeperreceiver/internal/metadata/generated_metrics_v2.go @@ -83,6 +83,58 @@ func DefaultMetricsSettings() MetricsSettings { } } +// AttributeDirection specifies the a value direction attribute. +type AttributeDirection int + +const ( + _ AttributeDirection = iota + AttributeDirectionReceived + AttributeDirectionSent +) + +// String returns the string representation of the AttributeDirection. +func (av AttributeDirection) String() string { + switch av { + case AttributeDirectionReceived: + return "received" + case AttributeDirectionSent: + return "sent" + } + return "" +} + +// MapAttributeDirection is a helper map of string to AttributeDirection attribute value. +var MapAttributeDirection = map[string]AttributeDirection{ + "received": AttributeDirectionReceived, + "sent": AttributeDirectionSent, +} + +// AttributeState specifies the a value state attribute. +type AttributeState int + +const ( + _ AttributeState = iota + AttributeStateSynced + AttributeStateUnsynced +) + +// String returns the string representation of the AttributeState. +func (av AttributeState) String() string { + switch av { + case AttributeStateSynced: + return "synced" + case AttributeStateUnsynced: + return "unsynced" + } + return "" +} + +// MapAttributeState is a helper map of string to AttributeState attribute value. +var MapAttributeState = map[string]AttributeState{ + "synced": AttributeStateSynced, + "unsynced": AttributeStateUnsynced, +} + type metricZookeeperConnectionActive struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -1001,8 +1053,8 @@ func (mb *MetricsBuilder) RecordZookeeperFileDescriptorOpenDataPoint(ts pcommon. } // RecordZookeeperFollowerCountDataPoint adds a data point to zookeeper.follower.count metric. -func (mb *MetricsBuilder) RecordZookeeperFollowerCountDataPoint(ts pcommon.Timestamp, val int64, stateAttributeValue string) { - mb.metricZookeeperFollowerCount.recordDataPoint(mb.startTime, ts, val, stateAttributeValue) +func (mb *MetricsBuilder) RecordZookeeperFollowerCountDataPoint(ts pcommon.Timestamp, val int64, stateAttributeValue AttributeState) { + mb.metricZookeeperFollowerCount.recordDataPoint(mb.startTime, ts, val, stateAttributeValue.String()) } // RecordZookeeperFsyncExceededThresholdCountDataPoint adds a data point to zookeeper.fsync.exceeded_threshold.count metric. @@ -1026,8 +1078,8 @@ func (mb *MetricsBuilder) RecordZookeeperLatencyMinDataPoint(ts pcommon.Timestam } // RecordZookeeperPacketCountDataPoint adds a data point to zookeeper.packet.count metric. -func (mb *MetricsBuilder) RecordZookeeperPacketCountDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue string) { - mb.metricZookeeperPacketCount.recordDataPoint(mb.startTime, ts, val, directionAttributeValue) +func (mb *MetricsBuilder) RecordZookeeperPacketCountDataPoint(ts pcommon.Timestamp, val int64, directionAttributeValue AttributeDirection) { + mb.metricZookeeperPacketCount.recordDataPoint(mb.startTime, ts, val, directionAttributeValue.String()) } // RecordZookeeperRequestActiveDataPoint adds a data point to zookeeper.request.active metric. @@ -1072,21 +1124,3 @@ var Attributes = struct { // A is an alias for Attributes. var A = Attributes - -// AttributeDirection are the possible values that the attribute "direction" can have. -var AttributeDirection = struct { - Received string - Sent string -}{ - "received", - "sent", -} - -// AttributeState are the possible values that the attribute "state" can have. -var AttributeState = struct { - Synced string - Unsynced string -}{ - "synced", - "unsynced", -} diff --git a/receiver/zookeeperreceiver/metrics.go b/receiver/zookeeperreceiver/metrics.go index e946291b2a00..0aeb045a5ea9 100644 --- a/receiver/zookeeperreceiver/metrics.go +++ b/receiver/zookeeperreceiver/metrics.go @@ -71,7 +71,7 @@ func (m *metricCreator) recordDataPointsFunc(metric string) func(ts pcommon.Time case syncedFollowersMetricKey: return func(ts pcommon.Timestamp, val int64) { m.computedMetricStore[syncedFollowersMetricKey] = val - m.mb.RecordZookeeperFollowerCountDataPoint(ts, val, metadata.AttributeState.Synced) + m.mb.RecordZookeeperFollowerCountDataPoint(ts, val, metadata.AttributeStateSynced) } case pendingSyncsMetricKey: return m.mb.RecordZookeeperSyncPendingDataPoint @@ -101,11 +101,11 @@ func (m *metricCreator) recordDataPointsFunc(metric string) func(ts pcommon.Time return m.mb.RecordZookeeperFsyncExceededThresholdCountDataPoint case packetsReceivedMetricKey: return func(ts pcommon.Timestamp, val int64) { - m.mb.RecordZookeeperPacketCountDataPoint(ts, val, metadata.AttributeDirection.Received) + m.mb.RecordZookeeperPacketCountDataPoint(ts, val, metadata.AttributeDirectionReceived) } case packetsSentMetricKey: return func(ts pcommon.Timestamp, val int64) { - m.mb.RecordZookeeperPacketCountDataPoint(ts, val, metadata.AttributeDirection.Sent) + m.mb.RecordZookeeperPacketCountDataPoint(ts, val, metadata.AttributeDirectionSent) } } @@ -132,7 +132,7 @@ func (m *metricCreator) computeNotSyncedFollowersMetric(ts pcommon.Timestamp) er } val := followersTotal - syncedFollowers - m.mb.RecordZookeeperFollowerCountDataPoint(ts, val, metadata.AttributeState.Unsynced) + m.mb.RecordZookeeperFollowerCountDataPoint(ts, val, metadata.AttributeStateUnsynced) return nil }