diff --git a/receiver/aerospikereceiver/documentation.md b/receiver/aerospikereceiver/documentation.md index 1dc71570d2c7..c1505ead92c4 100644 --- a/receiver/aerospikereceiver/documentation.md +++ b/receiver/aerospikereceiver/documentation.md @@ -9,13 +9,19 @@ These are the metrics available for this scraper. | Name | Description | Unit | Type | Attributes | | ---- | ----------- | ---- | ---- | ---------- | | **aerospike.namespace.disk.available** | Minimum percentage of contiguous disk space free to the namespace across all devices | % | Gauge(Int) | | +| **aerospike.namespace.geojson.region_query_cells** | Number of cell coverings for query region queried Number of cell coverings for query region queried. Aerospike metric geo_region_query_cells. | {cells} | Sum(Int) | | +| **aerospike.namespace.geojson.region_query_false_positive** | Number of points outside the region. Total query result points is geo_region_query_points + geo_region_query_falsepos. Aerospike metric geo_regio_query_falspos. | {points} | Sum(Int) | | +| **aerospike.namespace.geojson.region_query_points** | Number of points within the region. Total query result points is geo_region_query_points + geo_region_query_falsepos. Aerospike metric geo_region_query_points. | {points} | Sum(Int) | | +| **aerospike.namespace.geojson.region_query_requests** | Number of geojson queries on the system since the uptime of the node. Number of geojson queries on the system since the uptime of the node. Aerospike metric geo_region_query_reqs. | {queries} | Sum(Int) | | | **aerospike.namespace.memory.free** | Percentage of the namespace's memory which is still free Aerospike metric memory_free_pct | % | Gauge(Int) | | | **aerospike.namespace.memory.usage** | Memory currently used by each component of the namespace Aggregate of Aerospike Metrics memory_used_data_bytes, memory_used_index_bytes, memory_used_set_index_bytes, memory_used_sindex_bytes | By | Sum(Int) | | +| **aerospike.namespace.query.count** | Number of query operations performed on the namespace Aggregate of Aerospike Metrics query_aggr_abort, query_aggr_complete, query_aggr_error, query_basic_abort, query_basic_complete, query_basic_error, query_ops_bg_abort, query_ops_bg_complete, query_ops_bg_error, query_udf_bg_abort, query_udf_bg_complete, query_udf_bg_error, pi_query_aggr_abort, pi_query_aggr_complete, pi_query_aggr_error, pi_query_long_basic_abort, pi_query_long_basic_complete, pi_query_long_basic_error, pi_query_ops_bg_abort, pi_query_ops_bg_basic_complete, pi_query_ops_bg_basic_error, pi_query_short_basic_timeout, pi_query_short_basic_complete, pi_query_short_basic_error, pi_query_udf_bg_abort, pi_query_udf_bg_complete, pi_query_udf_bg_error, si_query_aggr_abort, si_query_aggr_complete, si_query_aggr_error, si_query_long_basic_abort, si_query_long_basic_complete, si_query_long_basic_error, si_query_ops_bg_abort, si_query_ops_bg_basic_complete, si_query_ops_bg_basic_error, si_query_short_basic_timeout, si_query_short_basic_complete, si_query_short_basic_error, si_query_udf_bg_abort, si_query_udf_bg_complete, si_query_udf_bg_error | {queries} | Sum(Int) | | | **aerospike.namespace.scan.count** | Number of scan operations performed on the namespace Aggregate of Aerospike Metrics scan_aggr_abort, scan_aggr_complete, scan_aggr_error, scan_basic_abort, scan_basic_complete, scan_basic_error, scan_ops_bg_abort, scan_ops_bg_complete, scan_ops_bg_error, scan_udf_bg_abort, scan_udf_bg_complete, scan_udf_bg_error | {scans} | Sum(Int) | | | **aerospike.namespace.transaction.count** | Number of transactions performed on the namespace Aggregate of Aerospike Metrics client_delete_error, client_delete_filtered_out, client_delete_not_found, client_delete_success, client_delete_timeout, client_read_error, client_read_filtered_out, client_read_not_found, client_read_success, client_read_timeout, client_udf_error, client_udf_filtered_out, client_udf_not_found, client_udf_success, client_udf_timeout, client_write_error, client_write_filtered_out, client_write_not_found, client_write_success, client_write_timeout | {transactions} | Sum(Int) | | | **aerospike.node.connection.count** | Number of connections opened and closed to the node Aggregate of Aerospike Metrics client_connections_closed, client_connections_opened, fabric_connections_closed, fabric_connections_opened, heartbeat_connections_closed, heartbeat_connections_opened | {connections} | Sum(Int) | | | **aerospike.node.connection.open** | Current number of open connections to the node Aggregate of Aerospike Metrics client_connections, fabric_connections, heartbeat_connections | {connections} | Sum(Int) | | | **aerospike.node.memory.free** | Percentage of the node's memory which is still free Aerospike Metric system_free_mem_pct | % | Gauge(Int) | | +| **aerospike.node.query.tracked** | Number of queries tracked by the system. Number of queries which ran more than query untracked_time (default 1 sec), Aerospike metric query_tracked | | Sum(Int) | | **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: @@ -39,7 +45,10 @@ metrics: | ---- | ----------- | ------ | | connection_op (operation) | Operation performed with a connection (open or close) | close, open | | connection_type (type) | Type of connection to an Aerospike node | client, fabric, heartbeat | +| index_type (index) | Type of index the operation was performed on | primary, secondary | | namespace_component (component) | Individual component of a namespace | data, index, set_index, secondary_index | +| query_result (result) | Result of a query operation performed on a namespace | abort, complete, error, timeout | +| query_type (type) | Type of query operation performed on a namespace | aggregation, basic, short, long_basic, short_basic, ops_background, udf_background | | scan_result (result) | Result of a scan operation performed on a namespace | abort, complete, error | | scan_type (type) | Type of scan operation performed on a namespace | aggregation, basic, ops_background, udf_background | | transaction_result (result) | Result of a transaction performed on a namespace | error, filtered_out, not_found, success, timeout | diff --git a/receiver/aerospikereceiver/internal/metadata/generated_metrics.go b/receiver/aerospikereceiver/internal/metadata/generated_metrics.go index d289c55882c1..819e87debfee 100644 --- a/receiver/aerospikereceiver/internal/metadata/generated_metrics.go +++ b/receiver/aerospikereceiver/internal/metadata/generated_metrics.go @@ -19,14 +19,20 @@ type MetricSettings struct { // MetricsSettings provides settings for aerospikereceiver metrics. type MetricsSettings struct { - AerospikeNamespaceDiskAvailable MetricSettings `mapstructure:"aerospike.namespace.disk.available"` - AerospikeNamespaceMemoryFree MetricSettings `mapstructure:"aerospike.namespace.memory.free"` - AerospikeNamespaceMemoryUsage MetricSettings `mapstructure:"aerospike.namespace.memory.usage"` - AerospikeNamespaceScanCount MetricSettings `mapstructure:"aerospike.namespace.scan.count"` - AerospikeNamespaceTransactionCount MetricSettings `mapstructure:"aerospike.namespace.transaction.count"` - AerospikeNodeConnectionCount MetricSettings `mapstructure:"aerospike.node.connection.count"` - AerospikeNodeConnectionOpen MetricSettings `mapstructure:"aerospike.node.connection.open"` - AerospikeNodeMemoryFree MetricSettings `mapstructure:"aerospike.node.memory.free"` + AerospikeNamespaceDiskAvailable MetricSettings `mapstructure:"aerospike.namespace.disk.available"` + AerospikeNamespaceGeojsonRegionQueryCells MetricSettings `mapstructure:"aerospike.namespace.geojson.region_query_cells"` + AerospikeNamespaceGeojsonRegionQueryFalsePositive MetricSettings `mapstructure:"aerospike.namespace.geojson.region_query_false_positive"` + AerospikeNamespaceGeojsonRegionQueryPoints MetricSettings `mapstructure:"aerospike.namespace.geojson.region_query_points"` + AerospikeNamespaceGeojsonRegionQueryRequests MetricSettings `mapstructure:"aerospike.namespace.geojson.region_query_requests"` + AerospikeNamespaceMemoryFree MetricSettings `mapstructure:"aerospike.namespace.memory.free"` + AerospikeNamespaceMemoryUsage MetricSettings `mapstructure:"aerospike.namespace.memory.usage"` + AerospikeNamespaceQueryCount MetricSettings `mapstructure:"aerospike.namespace.query.count"` + AerospikeNamespaceScanCount MetricSettings `mapstructure:"aerospike.namespace.scan.count"` + AerospikeNamespaceTransactionCount MetricSettings `mapstructure:"aerospike.namespace.transaction.count"` + AerospikeNodeConnectionCount MetricSettings `mapstructure:"aerospike.node.connection.count"` + AerospikeNodeConnectionOpen MetricSettings `mapstructure:"aerospike.node.connection.open"` + AerospikeNodeMemoryFree MetricSettings `mapstructure:"aerospike.node.memory.free"` + AerospikeNodeQueryTracked MetricSettings `mapstructure:"aerospike.node.query.tracked"` } func DefaultMetricsSettings() MetricsSettings { @@ -34,12 +40,27 @@ func DefaultMetricsSettings() MetricsSettings { AerospikeNamespaceDiskAvailable: MetricSettings{ Enabled: true, }, + AerospikeNamespaceGeojsonRegionQueryCells: MetricSettings{ + Enabled: true, + }, + AerospikeNamespaceGeojsonRegionQueryFalsePositive: MetricSettings{ + Enabled: true, + }, + AerospikeNamespaceGeojsonRegionQueryPoints: MetricSettings{ + Enabled: true, + }, + AerospikeNamespaceGeojsonRegionQueryRequests: MetricSettings{ + Enabled: true, + }, AerospikeNamespaceMemoryFree: MetricSettings{ Enabled: true, }, AerospikeNamespaceMemoryUsage: MetricSettings{ Enabled: true, }, + AerospikeNamespaceQueryCount: MetricSettings{ + Enabled: true, + }, AerospikeNamespaceScanCount: MetricSettings{ Enabled: true, }, @@ -55,6 +76,9 @@ func DefaultMetricsSettings() MetricsSettings { AerospikeNodeMemoryFree: MetricSettings{ Enabled: true, }, + AerospikeNodeQueryTracked: MetricSettings{ + Enabled: true, + }, } } @@ -114,6 +138,32 @@ var MapAttributeConnectionType = map[string]AttributeConnectionType{ "heartbeat": AttributeConnectionTypeHeartbeat, } +// AttributeIndexType specifies the a value index_type attribute. +type AttributeIndexType int + +const ( + _ AttributeIndexType = iota + AttributeIndexTypePrimary + AttributeIndexTypeSecondary +) + +// String returns the string representation of the AttributeIndexType. +func (av AttributeIndexType) String() string { + switch av { + case AttributeIndexTypePrimary: + return "primary" + case AttributeIndexTypeSecondary: + return "secondary" + } + return "" +} + +// MapAttributeIndexType is a helper map of string to AttributeIndexType attribute value. +var MapAttributeIndexType = map[string]AttributeIndexType{ + "primary": AttributeIndexTypePrimary, + "secondary": AttributeIndexTypeSecondary, +} + // AttributeNamespaceComponent specifies the a value namespace_component attribute. type AttributeNamespaceComponent int @@ -148,6 +198,86 @@ var MapAttributeNamespaceComponent = map[string]AttributeNamespaceComponent{ "secondary_index": AttributeNamespaceComponentSecondaryIndex, } +// AttributeQueryResult specifies the a value query_result attribute. +type AttributeQueryResult int + +const ( + _ AttributeQueryResult = iota + AttributeQueryResultAbort + AttributeQueryResultComplete + AttributeQueryResultError + AttributeQueryResultTimeout +) + +// String returns the string representation of the AttributeQueryResult. +func (av AttributeQueryResult) String() string { + switch av { + case AttributeQueryResultAbort: + return "abort" + case AttributeQueryResultComplete: + return "complete" + case AttributeQueryResultError: + return "error" + case AttributeQueryResultTimeout: + return "timeout" + } + return "" +} + +// MapAttributeQueryResult is a helper map of string to AttributeQueryResult attribute value. +var MapAttributeQueryResult = map[string]AttributeQueryResult{ + "abort": AttributeQueryResultAbort, + "complete": AttributeQueryResultComplete, + "error": AttributeQueryResultError, + "timeout": AttributeQueryResultTimeout, +} + +// AttributeQueryType specifies the a value query_type attribute. +type AttributeQueryType int + +const ( + _ AttributeQueryType = iota + AttributeQueryTypeAggregation + AttributeQueryTypeBasic + AttributeQueryTypeShort + AttributeQueryTypeLongBasic + AttributeQueryTypeShortBasic + AttributeQueryTypeOpsBackground + AttributeQueryTypeUdfBackground +) + +// String returns the string representation of the AttributeQueryType. +func (av AttributeQueryType) String() string { + switch av { + case AttributeQueryTypeAggregation: + return "aggregation" + case AttributeQueryTypeBasic: + return "basic" + case AttributeQueryTypeShort: + return "short" + case AttributeQueryTypeLongBasic: + return "long_basic" + case AttributeQueryTypeShortBasic: + return "short_basic" + case AttributeQueryTypeOpsBackground: + return "ops_background" + case AttributeQueryTypeUdfBackground: + return "udf_background" + } + return "" +} + +// MapAttributeQueryType is a helper map of string to AttributeQueryType attribute value. +var MapAttributeQueryType = map[string]AttributeQueryType{ + "aggregation": AttributeQueryTypeAggregation, + "basic": AttributeQueryTypeBasic, + "short": AttributeQueryTypeShort, + "long_basic": AttributeQueryTypeLongBasic, + "short_basic": AttributeQueryTypeShortBasic, + "ops_background": AttributeQueryTypeOpsBackground, + "udf_background": AttributeQueryTypeUdfBackground, +} + // AttributeScanResult specifies the a value scan_result attribute. type AttributeScanResult int @@ -333,6 +463,210 @@ func newMetricAerospikeNamespaceDiskAvailable(settings MetricSettings) metricAer return m } +type metricAerospikeNamespaceGeojsonRegionQueryCells struct { + data pmetric.Metric // data buffer for generated metric. + settings MetricSettings // metric settings provided by user. + capacity int // max observed number of data points added to the metric. +} + +// init fills aerospike.namespace.geojson.region_query_cells metric with initial data. +func (m *metricAerospikeNamespaceGeojsonRegionQueryCells) init() { + m.data.SetName("aerospike.namespace.geojson.region_query_cells") + m.data.SetDescription("Number of cell coverings for query region queried") + m.data.SetUnit("{cells}") + m.data.SetDataType(pmetric.MetricDataTypeSum) + m.data.Sum().SetIsMonotonic(true) + m.data.Sum().SetAggregationTemporality(pmetric.MetricAggregationTemporalityCumulative) +} + +func (m *metricAerospikeNamespaceGeojsonRegionQueryCells) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64) { + if !m.settings.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntVal(val) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricAerospikeNamespaceGeojsonRegionQueryCells) updateCapacity() { + if m.data.Sum().DataPoints().Len() > m.capacity { + m.capacity = m.data.Sum().DataPoints().Len() + } +} + +// emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. +func (m *metricAerospikeNamespaceGeojsonRegionQueryCells) emit(metrics pmetric.MetricSlice) { + if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricAerospikeNamespaceGeojsonRegionQueryCells(settings MetricSettings) metricAerospikeNamespaceGeojsonRegionQueryCells { + m := metricAerospikeNamespaceGeojsonRegionQueryCells{settings: settings} + if settings.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + +type metricAerospikeNamespaceGeojsonRegionQueryFalsePositive struct { + data pmetric.Metric // data buffer for generated metric. + settings MetricSettings // metric settings provided by user. + capacity int // max observed number of data points added to the metric. +} + +// init fills aerospike.namespace.geojson.region_query_false_positive metric with initial data. +func (m *metricAerospikeNamespaceGeojsonRegionQueryFalsePositive) init() { + m.data.SetName("aerospike.namespace.geojson.region_query_false_positive") + m.data.SetDescription("Number of points outside the region.") + m.data.SetUnit("{points}") + m.data.SetDataType(pmetric.MetricDataTypeSum) + m.data.Sum().SetIsMonotonic(true) + m.data.Sum().SetAggregationTemporality(pmetric.MetricAggregationTemporalityCumulative) +} + +func (m *metricAerospikeNamespaceGeojsonRegionQueryFalsePositive) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64) { + if !m.settings.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntVal(val) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricAerospikeNamespaceGeojsonRegionQueryFalsePositive) updateCapacity() { + if m.data.Sum().DataPoints().Len() > m.capacity { + m.capacity = m.data.Sum().DataPoints().Len() + } +} + +// emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. +func (m *metricAerospikeNamespaceGeojsonRegionQueryFalsePositive) emit(metrics pmetric.MetricSlice) { + if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricAerospikeNamespaceGeojsonRegionQueryFalsePositive(settings MetricSettings) metricAerospikeNamespaceGeojsonRegionQueryFalsePositive { + m := metricAerospikeNamespaceGeojsonRegionQueryFalsePositive{settings: settings} + if settings.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + +type metricAerospikeNamespaceGeojsonRegionQueryPoints struct { + data pmetric.Metric // data buffer for generated metric. + settings MetricSettings // metric settings provided by user. + capacity int // max observed number of data points added to the metric. +} + +// init fills aerospike.namespace.geojson.region_query_points metric with initial data. +func (m *metricAerospikeNamespaceGeojsonRegionQueryPoints) init() { + m.data.SetName("aerospike.namespace.geojson.region_query_points") + m.data.SetDescription("Number of points within the region.") + m.data.SetUnit("{points}") + m.data.SetDataType(pmetric.MetricDataTypeSum) + m.data.Sum().SetIsMonotonic(true) + m.data.Sum().SetAggregationTemporality(pmetric.MetricAggregationTemporalityCumulative) +} + +func (m *metricAerospikeNamespaceGeojsonRegionQueryPoints) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64) { + if !m.settings.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntVal(val) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricAerospikeNamespaceGeojsonRegionQueryPoints) updateCapacity() { + if m.data.Sum().DataPoints().Len() > m.capacity { + m.capacity = m.data.Sum().DataPoints().Len() + } +} + +// emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. +func (m *metricAerospikeNamespaceGeojsonRegionQueryPoints) emit(metrics pmetric.MetricSlice) { + if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricAerospikeNamespaceGeojsonRegionQueryPoints(settings MetricSettings) metricAerospikeNamespaceGeojsonRegionQueryPoints { + m := metricAerospikeNamespaceGeojsonRegionQueryPoints{settings: settings} + if settings.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + +type metricAerospikeNamespaceGeojsonRegionQueryRequests struct { + data pmetric.Metric // data buffer for generated metric. + settings MetricSettings // metric settings provided by user. + capacity int // max observed number of data points added to the metric. +} + +// init fills aerospike.namespace.geojson.region_query_requests metric with initial data. +func (m *metricAerospikeNamespaceGeojsonRegionQueryRequests) init() { + m.data.SetName("aerospike.namespace.geojson.region_query_requests") + m.data.SetDescription("Number of geojson queries on the system since the uptime of the node.") + m.data.SetUnit("{queries}") + m.data.SetDataType(pmetric.MetricDataTypeSum) + m.data.Sum().SetIsMonotonic(true) + m.data.Sum().SetAggregationTemporality(pmetric.MetricAggregationTemporalityCumulative) +} + +func (m *metricAerospikeNamespaceGeojsonRegionQueryRequests) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64) { + if !m.settings.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntVal(val) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricAerospikeNamespaceGeojsonRegionQueryRequests) updateCapacity() { + if m.data.Sum().DataPoints().Len() > m.capacity { + m.capacity = m.data.Sum().DataPoints().Len() + } +} + +// emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. +func (m *metricAerospikeNamespaceGeojsonRegionQueryRequests) emit(metrics pmetric.MetricSlice) { + if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricAerospikeNamespaceGeojsonRegionQueryRequests(settings MetricSettings) metricAerospikeNamespaceGeojsonRegionQueryRequests { + m := metricAerospikeNamespaceGeojsonRegionQueryRequests{settings: settings} + if settings.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + type metricAerospikeNamespaceMemoryFree struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -407,7 +741,7 @@ func (m *metricAerospikeNamespaceMemoryUsage) recordDataPoint(start pcommon.Time dp.SetStartTimestamp(start) dp.SetTimestamp(ts) dp.SetIntVal(val) - dp.Attributes().Insert("component", pcommon.NewValueString(namespaceComponentAttributeValue)) + dp.Attributes().InsertString("component", namespaceComponentAttributeValue) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. @@ -435,6 +769,61 @@ func newMetricAerospikeNamespaceMemoryUsage(settings MetricSettings) metricAeros return m } +type metricAerospikeNamespaceQueryCount struct { + data pmetric.Metric // data buffer for generated metric. + settings MetricSettings // metric settings provided by user. + capacity int // max observed number of data points added to the metric. +} + +// init fills aerospike.namespace.query.count metric with initial data. +func (m *metricAerospikeNamespaceQueryCount) init() { + m.data.SetName("aerospike.namespace.query.count") + m.data.SetDescription("Number of query operations performed on the namespace") + m.data.SetUnit("{queries}") + m.data.SetDataType(pmetric.MetricDataTypeSum) + m.data.Sum().SetIsMonotonic(true) + m.data.Sum().SetAggregationTemporality(pmetric.MetricAggregationTemporalityCumulative) + m.data.Sum().DataPoints().EnsureCapacity(m.capacity) +} + +func (m *metricAerospikeNamespaceQueryCount) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, queryTypeAttributeValue string, indexTypeAttributeValue string, queryResultAttributeValue string) { + if !m.settings.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntVal(val) + dp.Attributes().InsertString("type", queryTypeAttributeValue) + dp.Attributes().InsertString("index", indexTypeAttributeValue) + dp.Attributes().InsertString("result", queryResultAttributeValue) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricAerospikeNamespaceQueryCount) updateCapacity() { + if m.data.Sum().DataPoints().Len() > m.capacity { + m.capacity = m.data.Sum().DataPoints().Len() + } +} + +// emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. +func (m *metricAerospikeNamespaceQueryCount) emit(metrics pmetric.MetricSlice) { + if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricAerospikeNamespaceQueryCount(settings MetricSettings) metricAerospikeNamespaceQueryCount { + m := metricAerospikeNamespaceQueryCount{settings: settings} + if settings.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + type metricAerospikeNamespaceScanCount struct { data pmetric.Metric // data buffer for generated metric. settings MetricSettings // metric settings provided by user. @@ -460,8 +849,8 @@ func (m *metricAerospikeNamespaceScanCount) recordDataPoint(start pcommon.Timest dp.SetStartTimestamp(start) dp.SetTimestamp(ts) dp.SetIntVal(val) - dp.Attributes().Insert("type", pcommon.NewValueString(scanTypeAttributeValue)) - dp.Attributes().Insert("result", pcommon.NewValueString(scanResultAttributeValue)) + dp.Attributes().InsertString("type", scanTypeAttributeValue) + dp.Attributes().InsertString("result", scanResultAttributeValue) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. @@ -514,8 +903,8 @@ func (m *metricAerospikeNamespaceTransactionCount) recordDataPoint(start pcommon dp.SetStartTimestamp(start) dp.SetTimestamp(ts) dp.SetIntVal(val) - dp.Attributes().Insert("type", pcommon.NewValueString(transactionTypeAttributeValue)) - dp.Attributes().Insert("result", pcommon.NewValueString(transactionResultAttributeValue)) + dp.Attributes().InsertString("type", transactionTypeAttributeValue) + dp.Attributes().InsertString("result", transactionResultAttributeValue) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. @@ -568,8 +957,8 @@ func (m *metricAerospikeNodeConnectionCount) recordDataPoint(start pcommon.Times dp.SetStartTimestamp(start) dp.SetTimestamp(ts) dp.SetIntVal(val) - dp.Attributes().Insert("type", pcommon.NewValueString(connectionTypeAttributeValue)) - dp.Attributes().Insert("operation", pcommon.NewValueString(connectionOpAttributeValue)) + dp.Attributes().InsertString("type", connectionTypeAttributeValue) + dp.Attributes().InsertString("operation", connectionOpAttributeValue) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. @@ -622,7 +1011,7 @@ func (m *metricAerospikeNodeConnectionOpen) recordDataPoint(start pcommon.Timest dp.SetStartTimestamp(start) dp.SetTimestamp(ts) dp.SetIntVal(val) - dp.Attributes().Insert("type", pcommon.NewValueString(connectionTypeAttributeValue)) + dp.Attributes().InsertString("type", connectionTypeAttributeValue) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. @@ -699,22 +1088,79 @@ func newMetricAerospikeNodeMemoryFree(settings MetricSettings) metricAerospikeNo return m } +type metricAerospikeNodeQueryTracked struct { + data pmetric.Metric // data buffer for generated metric. + settings MetricSettings // metric settings provided by user. + capacity int // max observed number of data points added to the metric. +} + +// init fills aerospike.node.query.tracked metric with initial data. +func (m *metricAerospikeNodeQueryTracked) init() { + m.data.SetName("aerospike.node.query.tracked") + m.data.SetDescription("Number of queries tracked by the system.") + m.data.SetUnit("") + m.data.SetDataType(pmetric.MetricDataTypeSum) + m.data.Sum().SetIsMonotonic(true) + m.data.Sum().SetAggregationTemporality(pmetric.MetricAggregationTemporalityCumulative) +} + +func (m *metricAerospikeNodeQueryTracked) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64) { + if !m.settings.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntVal(val) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricAerospikeNodeQueryTracked) updateCapacity() { + if m.data.Sum().DataPoints().Len() > m.capacity { + m.capacity = m.data.Sum().DataPoints().Len() + } +} + +// emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. +func (m *metricAerospikeNodeQueryTracked) emit(metrics pmetric.MetricSlice) { + if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricAerospikeNodeQueryTracked(settings MetricSettings) metricAerospikeNodeQueryTracked { + m := metricAerospikeNodeQueryTracked{settings: settings} + if settings.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + // MetricsBuilder provides an interface for scrapers to report metrics while taking care of all the transformations // required to produce metric representation defined in metadata and user settings. type MetricsBuilder struct { - startTime pcommon.Timestamp // start time that will be applied to all recorded data points. - metricsCapacity int // maximum observed number of metrics per resource. - resourceCapacity int // maximum observed number of resource attributes. - metricsBuffer pmetric.Metrics // accumulates metrics data before emitting. - buildInfo component.BuildInfo // contains version information - metricAerospikeNamespaceDiskAvailable metricAerospikeNamespaceDiskAvailable - metricAerospikeNamespaceMemoryFree metricAerospikeNamespaceMemoryFree - metricAerospikeNamespaceMemoryUsage metricAerospikeNamespaceMemoryUsage - metricAerospikeNamespaceScanCount metricAerospikeNamespaceScanCount - metricAerospikeNamespaceTransactionCount metricAerospikeNamespaceTransactionCount - metricAerospikeNodeConnectionCount metricAerospikeNodeConnectionCount - metricAerospikeNodeConnectionOpen metricAerospikeNodeConnectionOpen - metricAerospikeNodeMemoryFree metricAerospikeNodeMemoryFree + startTime pcommon.Timestamp // start time that will be applied to all recorded data points. + metricsCapacity int // maximum observed number of metrics per resource. + resourceCapacity int // maximum observed number of resource attributes. + metricsBuffer pmetric.Metrics // accumulates metrics data before emitting. + buildInfo component.BuildInfo // contains version information + metricAerospikeNamespaceDiskAvailable metricAerospikeNamespaceDiskAvailable + metricAerospikeNamespaceGeojsonRegionQueryCells metricAerospikeNamespaceGeojsonRegionQueryCells + metricAerospikeNamespaceGeojsonRegionQueryFalsePositive metricAerospikeNamespaceGeojsonRegionQueryFalsePositive + metricAerospikeNamespaceGeojsonRegionQueryPoints metricAerospikeNamespaceGeojsonRegionQueryPoints + metricAerospikeNamespaceGeojsonRegionQueryRequests metricAerospikeNamespaceGeojsonRegionQueryRequests + metricAerospikeNamespaceMemoryFree metricAerospikeNamespaceMemoryFree + metricAerospikeNamespaceMemoryUsage metricAerospikeNamespaceMemoryUsage + metricAerospikeNamespaceQueryCount metricAerospikeNamespaceQueryCount + metricAerospikeNamespaceScanCount metricAerospikeNamespaceScanCount + metricAerospikeNamespaceTransactionCount metricAerospikeNamespaceTransactionCount + metricAerospikeNodeConnectionCount metricAerospikeNodeConnectionCount + metricAerospikeNodeConnectionOpen metricAerospikeNodeConnectionOpen + metricAerospikeNodeMemoryFree metricAerospikeNodeMemoryFree + metricAerospikeNodeQueryTracked metricAerospikeNodeQueryTracked } // metricBuilderOption applies changes to default metrics builder. @@ -729,17 +1175,23 @@ func WithStartTime(startTime pcommon.Timestamp) metricBuilderOption { func NewMetricsBuilder(settings MetricsSettings, buildInfo component.BuildInfo, options ...metricBuilderOption) *MetricsBuilder { mb := &MetricsBuilder{ - startTime: pcommon.NewTimestampFromTime(time.Now()), - metricsBuffer: pmetric.NewMetrics(), - buildInfo: buildInfo, - metricAerospikeNamespaceDiskAvailable: newMetricAerospikeNamespaceDiskAvailable(settings.AerospikeNamespaceDiskAvailable), - metricAerospikeNamespaceMemoryFree: newMetricAerospikeNamespaceMemoryFree(settings.AerospikeNamespaceMemoryFree), - metricAerospikeNamespaceMemoryUsage: newMetricAerospikeNamespaceMemoryUsage(settings.AerospikeNamespaceMemoryUsage), - metricAerospikeNamespaceScanCount: newMetricAerospikeNamespaceScanCount(settings.AerospikeNamespaceScanCount), - metricAerospikeNamespaceTransactionCount: newMetricAerospikeNamespaceTransactionCount(settings.AerospikeNamespaceTransactionCount), - metricAerospikeNodeConnectionCount: newMetricAerospikeNodeConnectionCount(settings.AerospikeNodeConnectionCount), - metricAerospikeNodeConnectionOpen: newMetricAerospikeNodeConnectionOpen(settings.AerospikeNodeConnectionOpen), - metricAerospikeNodeMemoryFree: newMetricAerospikeNodeMemoryFree(settings.AerospikeNodeMemoryFree), + startTime: pcommon.NewTimestampFromTime(time.Now()), + metricsBuffer: pmetric.NewMetrics(), + buildInfo: buildInfo, + metricAerospikeNamespaceDiskAvailable: newMetricAerospikeNamespaceDiskAvailable(settings.AerospikeNamespaceDiskAvailable), + metricAerospikeNamespaceGeojsonRegionQueryCells: newMetricAerospikeNamespaceGeojsonRegionQueryCells(settings.AerospikeNamespaceGeojsonRegionQueryCells), + metricAerospikeNamespaceGeojsonRegionQueryFalsePositive: newMetricAerospikeNamespaceGeojsonRegionQueryFalsePositive(settings.AerospikeNamespaceGeojsonRegionQueryFalsePositive), + metricAerospikeNamespaceGeojsonRegionQueryPoints: newMetricAerospikeNamespaceGeojsonRegionQueryPoints(settings.AerospikeNamespaceGeojsonRegionQueryPoints), + metricAerospikeNamespaceGeojsonRegionQueryRequests: newMetricAerospikeNamespaceGeojsonRegionQueryRequests(settings.AerospikeNamespaceGeojsonRegionQueryRequests), + metricAerospikeNamespaceMemoryFree: newMetricAerospikeNamespaceMemoryFree(settings.AerospikeNamespaceMemoryFree), + metricAerospikeNamespaceMemoryUsage: newMetricAerospikeNamespaceMemoryUsage(settings.AerospikeNamespaceMemoryUsage), + metricAerospikeNamespaceQueryCount: newMetricAerospikeNamespaceQueryCount(settings.AerospikeNamespaceQueryCount), + metricAerospikeNamespaceScanCount: newMetricAerospikeNamespaceScanCount(settings.AerospikeNamespaceScanCount), + metricAerospikeNamespaceTransactionCount: newMetricAerospikeNamespaceTransactionCount(settings.AerospikeNamespaceTransactionCount), + metricAerospikeNodeConnectionCount: newMetricAerospikeNodeConnectionCount(settings.AerospikeNodeConnectionCount), + metricAerospikeNodeConnectionOpen: newMetricAerospikeNodeConnectionOpen(settings.AerospikeNodeConnectionOpen), + metricAerospikeNodeMemoryFree: newMetricAerospikeNodeMemoryFree(settings.AerospikeNodeMemoryFree), + metricAerospikeNodeQueryTracked: newMetricAerospikeNodeQueryTracked(settings.AerospikeNodeQueryTracked), } for _, op := range options { op(mb) @@ -807,13 +1259,19 @@ func (mb *MetricsBuilder) EmitForResource(rmo ...ResourceMetricsOption) { ils.Scope().SetVersion(mb.buildInfo.Version) ils.Metrics().EnsureCapacity(mb.metricsCapacity) mb.metricAerospikeNamespaceDiskAvailable.emit(ils.Metrics()) + mb.metricAerospikeNamespaceGeojsonRegionQueryCells.emit(ils.Metrics()) + mb.metricAerospikeNamespaceGeojsonRegionQueryFalsePositive.emit(ils.Metrics()) + mb.metricAerospikeNamespaceGeojsonRegionQueryPoints.emit(ils.Metrics()) + mb.metricAerospikeNamespaceGeojsonRegionQueryRequests.emit(ils.Metrics()) mb.metricAerospikeNamespaceMemoryFree.emit(ils.Metrics()) mb.metricAerospikeNamespaceMemoryUsage.emit(ils.Metrics()) + mb.metricAerospikeNamespaceQueryCount.emit(ils.Metrics()) mb.metricAerospikeNamespaceScanCount.emit(ils.Metrics()) mb.metricAerospikeNamespaceTransactionCount.emit(ils.Metrics()) mb.metricAerospikeNodeConnectionCount.emit(ils.Metrics()) mb.metricAerospikeNodeConnectionOpen.emit(ils.Metrics()) mb.metricAerospikeNodeMemoryFree.emit(ils.Metrics()) + mb.metricAerospikeNodeQueryTracked.emit(ils.Metrics()) for _, op := range rmo { op(rm) } @@ -843,6 +1301,46 @@ func (mb *MetricsBuilder) RecordAerospikeNamespaceDiskAvailableDataPoint(ts pcom return nil } +// RecordAerospikeNamespaceGeojsonRegionQueryCellsDataPoint adds a data point to aerospike.namespace.geojson.region_query_cells metric. +func (mb *MetricsBuilder) RecordAerospikeNamespaceGeojsonRegionQueryCellsDataPoint(ts pcommon.Timestamp, inputVal string) error { + val, err := strconv.ParseInt(inputVal, 10, 64) + if err != nil { + return fmt.Errorf("failed to parse int64 for AerospikeNamespaceGeojsonRegionQueryCells, value was %s: %w", inputVal, err) + } + mb.metricAerospikeNamespaceGeojsonRegionQueryCells.recordDataPoint(mb.startTime, ts, val) + return nil +} + +// RecordAerospikeNamespaceGeojsonRegionQueryFalsePositiveDataPoint adds a data point to aerospike.namespace.geojson.region_query_false_positive metric. +func (mb *MetricsBuilder) RecordAerospikeNamespaceGeojsonRegionQueryFalsePositiveDataPoint(ts pcommon.Timestamp, inputVal string) error { + val, err := strconv.ParseInt(inputVal, 10, 64) + if err != nil { + return fmt.Errorf("failed to parse int64 for AerospikeNamespaceGeojsonRegionQueryFalsePositive, value was %s: %w", inputVal, err) + } + mb.metricAerospikeNamespaceGeojsonRegionQueryFalsePositive.recordDataPoint(mb.startTime, ts, val) + return nil +} + +// RecordAerospikeNamespaceGeojsonRegionQueryPointsDataPoint adds a data point to aerospike.namespace.geojson.region_query_points metric. +func (mb *MetricsBuilder) RecordAerospikeNamespaceGeojsonRegionQueryPointsDataPoint(ts pcommon.Timestamp, inputVal string) error { + val, err := strconv.ParseInt(inputVal, 10, 64) + if err != nil { + return fmt.Errorf("failed to parse int64 for AerospikeNamespaceGeojsonRegionQueryPoints, value was %s: %w", inputVal, err) + } + mb.metricAerospikeNamespaceGeojsonRegionQueryPoints.recordDataPoint(mb.startTime, ts, val) + return nil +} + +// RecordAerospikeNamespaceGeojsonRegionQueryRequestsDataPoint adds a data point to aerospike.namespace.geojson.region_query_requests metric. +func (mb *MetricsBuilder) RecordAerospikeNamespaceGeojsonRegionQueryRequestsDataPoint(ts pcommon.Timestamp, inputVal string) error { + val, err := strconv.ParseInt(inputVal, 10, 64) + if err != nil { + return fmt.Errorf("failed to parse int64 for AerospikeNamespaceGeojsonRegionQueryRequests, value was %s: %w", inputVal, err) + } + mb.metricAerospikeNamespaceGeojsonRegionQueryRequests.recordDataPoint(mb.startTime, ts, val) + return nil +} + // RecordAerospikeNamespaceMemoryFreeDataPoint adds a data point to aerospike.namespace.memory.free metric. func (mb *MetricsBuilder) RecordAerospikeNamespaceMemoryFreeDataPoint(ts pcommon.Timestamp, inputVal string) error { val, err := strconv.ParseInt(inputVal, 10, 64) @@ -863,6 +1361,16 @@ func (mb *MetricsBuilder) RecordAerospikeNamespaceMemoryUsageDataPoint(ts pcommo return nil } +// RecordAerospikeNamespaceQueryCountDataPoint adds a data point to aerospike.namespace.query.count metric. +func (mb *MetricsBuilder) RecordAerospikeNamespaceQueryCountDataPoint(ts pcommon.Timestamp, inputVal string, queryTypeAttributeValue AttributeQueryType, indexTypeAttributeValue AttributeIndexType, queryResultAttributeValue AttributeQueryResult) error { + val, err := strconv.ParseInt(inputVal, 10, 64) + if err != nil { + return fmt.Errorf("failed to parse int64 for AerospikeNamespaceQueryCount, value was %s: %w", inputVal, err) + } + mb.metricAerospikeNamespaceQueryCount.recordDataPoint(mb.startTime, ts, val, queryTypeAttributeValue.String(), indexTypeAttributeValue.String(), queryResultAttributeValue.String()) + return nil +} + // RecordAerospikeNamespaceScanCountDataPoint adds a data point to aerospike.namespace.scan.count metric. func (mb *MetricsBuilder) RecordAerospikeNamespaceScanCountDataPoint(ts pcommon.Timestamp, inputVal string, scanTypeAttributeValue AttributeScanType, scanResultAttributeValue AttributeScanResult) error { val, err := strconv.ParseInt(inputVal, 10, 64) @@ -913,6 +1421,16 @@ func (mb *MetricsBuilder) RecordAerospikeNodeMemoryFreeDataPoint(ts pcommon.Time return nil } +// RecordAerospikeNodeQueryTrackedDataPoint adds a data point to aerospike.node.query.tracked metric. +func (mb *MetricsBuilder) RecordAerospikeNodeQueryTrackedDataPoint(ts pcommon.Timestamp, inputVal string) error { + val, err := strconv.ParseInt(inputVal, 10, 64) + if err != nil { + return fmt.Errorf("failed to parse int64 for AerospikeNodeQueryTracked, value was %s: %w", inputVal, err) + } + mb.metricAerospikeNodeQueryTracked.recordDataPoint(mb.startTime, ts, val) + return nil +} + // Reset resets metrics builder to its initial state. It should be used when external metrics source is restarted, // and metrics builder should update its startTime and reset it's internal state accordingly. func (mb *MetricsBuilder) Reset(options ...metricBuilderOption) { diff --git a/receiver/aerospikereceiver/metadata.yaml b/receiver/aerospikereceiver/metadata.yaml index 560977865cfa..ebf3fc86b7e9 100644 --- a/receiver/aerospikereceiver/metadata.yaml +++ b/receiver/aerospikereceiver/metadata.yaml @@ -32,6 +32,31 @@ attributes: - abort - complete - error + index_type: + value: index + description: Type of index the operation was performed on + enum: + - primary + - secondary + query_type: + value: type + description: Type of query operation performed on a namespace + enum: + - aggregation + - basic + - short + - long_basic + - short_basic + - ops_background + - udf_background + query_result: + value: result + description: Result of a query operation performed on a namespace + enum: + - abort + - complete + - error + - timeout # short_basic queries only transaction_type: value: type description: Type of transaction performed on a namespace @@ -94,6 +119,15 @@ metrics: input_type: string monotonic: false aggregation: cumulative + aerospike.node.query.tracked: + enabled: true + description: Number of queries tracked by the system. + extended_documentation: Number of queries which ran more than query untracked_time (default 1 sec), Aerospike metric query_tracked + sum: + value_type: int + input_type: string + monotonic: true + aggregation: cumulative aerospike.namespace.memory.usage: enabled: true description: Memory currently used by each component of the namespace @@ -131,6 +165,57 @@ metrics: input_type: string monotonic: true aggregation: cumulative + aerospike.namespace.query.count: + enabled: true + description: Number of query operations performed on the namespace + unit: '{queries}' + extended_documentation: Aggregate of Aerospike Metrics query_aggr_abort, query_aggr_complete, query_aggr_error, query_basic_abort, query_basic_complete, query_basic_error, query_ops_bg_abort, query_ops_bg_complete, query_ops_bg_error, query_udf_bg_abort, query_udf_bg_complete, query_udf_bg_error, pi_query_aggr_abort, pi_query_aggr_complete, pi_query_aggr_error, pi_query_long_basic_abort, pi_query_long_basic_complete, pi_query_long_basic_error, pi_query_ops_bg_abort, pi_query_ops_bg_basic_complete, pi_query_ops_bg_basic_error, pi_query_short_basic_timeout, pi_query_short_basic_complete, pi_query_short_basic_error, pi_query_udf_bg_abort, pi_query_udf_bg_complete, pi_query_udf_bg_error, si_query_aggr_abort, si_query_aggr_complete, si_query_aggr_error, si_query_long_basic_abort, si_query_long_basic_complete, si_query_long_basic_error, si_query_ops_bg_abort, si_query_ops_bg_basic_complete, si_query_ops_bg_basic_error, si_query_short_basic_timeout, si_query_short_basic_complete, si_query_short_basic_error, si_query_udf_bg_abort, si_query_udf_bg_complete, si_query_udf_bg_error + attributes: [query_type, index_type, query_result] + sum: + value_type: int + input_type: string + monotonic: true + aggregation: cumulative + aerospike.namespace.geojson.region_query_cells: + enabled: true + description: Number of cell coverings for query region queried + unit: '{cells}' + extended_documentation: Number of cell coverings for query region queried. Aerospike metric geo_region_query_cells. + sum: + value_type: int + input_type: string + monotonic: true + aggregation: cumulative + aerospike.namespace.geojson.region_query_false_positive: + enabled: true + description: Number of points outside the region. + unit: '{points}' + extended_documentation: Total query result points is geo_region_query_points + geo_region_query_falsepos. Aerospike metric geo_regio_query_falspos. + sum: + value_type: int + input_type: string + monotonic: true + aggregation: cumulative + aerospike.namespace.geojson.region_query_points: + enabled: true + description: Number of points within the region. + unit: '{points}' + extended_documentation: Total query result points is geo_region_query_points + geo_region_query_falsepos. Aerospike metric geo_region_query_points. + sum: + value_type: int + input_type: string + monotonic: true + aggregation: cumulative + aerospike.namespace.geojson.region_query_requests: + enabled: true + description: Number of geojson queries on the system since the uptime of the node. + unit: '{queries}' + extended_documentation: Number of geojson queries on the system since the uptime of the node. Aerospike metric geo_region_query_reqs. + sum: + value_type: int + input_type: string + monotonic: true + aggregation: cumulative aerospike.namespace.transaction.count: enabled: true description: Number of transactions performed on the namespace diff --git a/receiver/aerospikereceiver/scraper.go b/receiver/aerospikereceiver/scraper.go index 05a77782e50d..2457524392d7 100644 --- a/receiver/aerospikereceiver/scraper.go +++ b/receiver/aerospikereceiver/scraper.go @@ -171,6 +171,8 @@ func (r *aerospikeReceiver) emitNode(info map[string]string, now pcommon.Timesta addPartialIfError(errs, r.mb.RecordAerospikeNodeConnectionCountDataPoint(now, v, metadata.AttributeConnectionTypeHeartbeat, metadata.AttributeConnectionOpOpen)) case "system_free_mem_pct": addPartialIfError(errs, r.mb.RecordAerospikeNodeMemoryFreeDataPoint(now, v)) + case "query_tracked": + addPartialIfError(errs, r.mb.RecordAerospikeNodeQueryTrackedDataPoint(now, v)) } } @@ -240,6 +242,108 @@ func (r *aerospikeReceiver) emitNamespace(info map[string]string, now pcommon.Ti case "scan_udf_bg_error": addPartialIfError(errs, r.mb.RecordAerospikeNamespaceScanCountDataPoint(now, v, metadata.AttributeScanTypeUdfBackground, metadata.AttributeScanResultError)) + // Pre Aerospike 6.0 query metrics. These were always done on secondary indexes, otherwise they were counted as a scan. + case "query_aggr_abort": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeAggregation, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultAbort)) + case "query_aggr_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeAggregation, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultComplete)) + case "query_aggr_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeAggregation, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultError)) + case "query_basic_abort": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeBasic, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultAbort)) + case "query_basic_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeBasic, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultComplete)) + case "query_basic_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeBasic, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultError)) + case "query_ops_bg_abort": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeOpsBackground, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultAbort)) + case "query_ops_bg_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeOpsBackground, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultComplete)) + case "query_ops_bg_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeOpsBackground, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultError)) + case "query_udf_bg_abort": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeUdfBackground, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultAbort)) + case "query_udf_bg_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeUdfBackground, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultComplete)) + case "query_udf_bg_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeUdfBackground, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultError)) + + // PI queries + case "pi_query_aggr_abort": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeAggregation, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultAbort)) + case "pi_query_aggr_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeAggregation, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultComplete)) + case "pi_query_aggr_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeAggregation, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultError)) + case "pi_query_long_basic_abort": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeLongBasic, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultAbort)) + case "pi_query_long_basic_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeLongBasic, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultComplete)) + case "pi_query_long_basic_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeLongBasic, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultError)) + case "pi_query_ops_bg_abort": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeOpsBackground, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultAbort)) + case "pi_query_ops_bg_basic_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeOpsBackground, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultComplete)) + case "pi_query_ops_bg_basic_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeOpsBackground, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultError)) + case "pi_query_short_basic_timeout": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeShortBasic, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultTimeout)) + case "pi_query_short_basic_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeShortBasic, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultComplete)) + case "pi_query_short_basic_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeShortBasic, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultError)) + case "pi_query_udf_bg_abort": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeUdfBackground, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultAbort)) + case "pi_query_udf_bg_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeUdfBackground, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultComplete)) + case "pi_query_udf_bg_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeUdfBackground, metadata.AttributeIndexTypePrimary, metadata.AttributeQueryResultError)) + + // SI queries + case "si_query_aggr_abort": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeAggregation, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultAbort)) + case "si_query_aggr_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeAggregation, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultComplete)) + case "si_query_aggr_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeAggregation, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultError)) + case "si_query_long_basic_abort": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeLongBasic, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultAbort)) + case "si_query_long_basic_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeLongBasic, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultComplete)) + case "si_query_long_basic_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeLongBasic, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultError)) + case "si_query_ops_bg_abort": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeOpsBackground, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultAbort)) + case "si_query_ops_bg_basic_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeOpsBackground, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultComplete)) + case "si_query_ops_bg_basic_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeOpsBackground, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultError)) + case "si_query_short_basic_timeout": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeShortBasic, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultTimeout)) + case "si_query_short_basic_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeShortBasic, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultComplete)) + case "si_query_short_basic_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeShortBasic, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultError)) + case "si_query_udf_bg_abort": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeUdfBackground, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultAbort)) + case "si_query_udf_bg_complete": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeUdfBackground, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultComplete)) + case "si_query_udf_bg_error": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceQueryCountDataPoint(now, v, metadata.AttributeQueryTypeUdfBackground, metadata.AttributeIndexTypeSecondary, metadata.AttributeQueryResultError)) + + // GeoJSON region queries + case "geo_region_query_cells": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceGeojsonRegionQueryCellsDataPoint(now, v)) + case "geo_region_query_falsepos": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceGeojsonRegionQueryFalsePositiveDataPoint(now, v)) + case "geo_region_query_points": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceGeojsonRegionQueryPointsDataPoint(now, v)) + case "geo_region_query_reqs": + addPartialIfError(errs, r.mb.RecordAerospikeNamespaceGeojsonRegionQueryRequestsDataPoint(now, v)) + + // Compression + // 'Delete' transactions case "client_delete_error": addPartialIfError(errs, r.mb.RecordAerospikeNamespaceTransactionCountDataPoint(now, v, metadata.AttributeTransactionTypeDelete, metadata.AttributeTransactionResultError)) diff --git a/receiver/aerospikereceiver/testdata/integration/expected.json b/receiver/aerospikereceiver/testdata/integration/expected.json index 40953bfd01a0..b82720c6e450 100644 --- a/receiver/aerospikereceiver/testdata/integration/expected.json +++ b/receiver/aerospikereceiver/testdata/integration/expected.json @@ -1,906 +1,1280 @@ { - "resourceMetrics": [ - { - "resource": { - "attributes": [ - { - "key": "aerospike.node.name", - "value": { - "stringValue": "BB9020011AC4202" - } - } - ] - }, - "scopeMetrics": [ - { - "metrics": [ - { - "description": "Number of connections opened and closed to the node", - "name": "aerospike.node.connection.count", - "sum": { - "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", - "dataPoints": [ - { - "asInt": "2", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "heartbeat" - } - }, - { - "key": "operation", - "value": { - "stringValue": "open" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "heartbeat" - } - }, - { - "key": "operation", - "value": { - "stringValue": "close" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "12", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "client" - } - }, - { - "key": "operation", - "value": { - "stringValue": "close" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "48", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "fabric" - } - }, - { - "key": "operation", - "value": { - "stringValue": "open" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "13", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "client" - } - }, - { - "key": "operation", - "value": { - "stringValue": "open" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "fabric" - } - }, - { - "key": "operation", - "value": { - "stringValue": "close" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - } - ], - "isMonotonic": true - }, - "unit": "{connections}" - }, - { - "description": "Current number of open connections to the node", - "name": "aerospike.node.connection.open", - "sum": { - "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", - "dataPoints": [ - { - "asInt": "2", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "heartbeat" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "48", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "fabric" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "1", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "client" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - } - ] - }, - "unit": "{connections}" - }, - { - "description": "Percentage of the node's memory which is still free", - "gauge": { - "dataPoints": [ - { - "asInt": "66", - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - } - ] - }, - "name": "aerospike.node.memory.free", - "unit": "%" - } - ], - "scope": { - "name": "otelcol/aerospikereceiver", - "version": "latest" - } - } - ] - }, - { - "resource": { - "attributes": [ - { - "key": "aerospike.namespace", - "value": { - "stringValue": "test" - } - }, - { - "key": "aerospike.node.name", - "value": { - "stringValue": "BB9020011AC4202" - } - } - ] - }, - "scopeMetrics": [ - { - "metrics": [ - { - "description": "Minimum percentage of contiguous disk space free to the namespace across all devices", - "gauge": { - "dataPoints": [ - { - "asInt": "98", - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - } - ] - }, - "name": "aerospike.namespace.disk.available", - "unit": "%" - }, - { - "description": "Percentage of the namespace's memory which is still free", - "gauge": { - "dataPoints": [ - { - "asInt": "96", - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - } - ] - }, - "name": "aerospike.namespace.memory.free", - "unit": "%" - }, - { - "description": "Memory currently used by each component of the namespace", - "name": "aerospike.namespace.memory.usage", - "sum": { - "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", - "dataPoints": [ - { - "asInt": "0", - "attributes": [ - { - "key": "component", - "value": { - "stringValue": "secondary_index" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "32059712", - "attributes": [ - { - "key": "component", - "value": { - "stringValue": "index" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "component", - "value": { - "stringValue": "set_index" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "6512129", - "attributes": [ - { - "key": "component", - "value": { - "stringValue": "data" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - } - ] - }, - "unit": "By" - }, - { - "description": "Number of scan operations performed on the namespace", - "name": "aerospike.namespace.scan.count", - "sum": { - "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", - "dataPoints": [ - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "ops_background" - } - }, - { - "key": "result", - "value": { - "stringValue": "abort" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "udf_background" - } - }, - { - "key": "result", - "value": { - "stringValue": "abort" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "udf_background" - } - }, - { - "key": "result", - "value": { - "stringValue": "error" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "aggregation" - } - }, - { - "key": "result", - "value": { - "stringValue": "abort" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "aggregation" - } - }, - { - "key": "result", - "value": { - "stringValue": "complete" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "basic" - } - }, - { - "key": "result", - "value": { - "stringValue": "abort" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "udf_background" - } - }, - { - "key": "result", - "value": { - "stringValue": "complete" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "ops_background" - } - }, - { - "key": "result", - "value": { - "stringValue": "error" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "basic" - } - }, - { - "key": "result", - "value": { - "stringValue": "error" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "aggregation" - } - }, - { - "key": "result", - "value": { - "stringValue": "error" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "ops_background" - } - }, - { - "key": "result", - "value": { - "stringValue": "complete" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "basic" - } - }, - { - "key": "result", - "value": { - "stringValue": "complete" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - } - ], - "isMonotonic": true - }, - "unit": "{scans}" - }, - { - "description": "Number of transactions performed on the namespace", - "name": "aerospike.namespace.transaction.count", - "sum": { - "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", - "dataPoints": [ - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "delete" - } - }, - { - "key": "result", - "value": { - "stringValue": "not_found" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "udf" - } - }, - { - "key": "result", - "value": { - "stringValue": "error" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "write" - } - }, - { - "key": "result", - "value": { - "stringValue": "error" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "read" - } - }, - { - "key": "result", - "value": { - "stringValue": "success" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "write" - } - }, - { - "key": "result", - "value": { - "stringValue": "filtered_out" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "udf" - } - }, - { - "key": "result", - "value": { - "stringValue": "filtered_out" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "delete" - } - }, - { - "key": "result", - "value": { - "stringValue": "success" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "write" - } - }, - { - "key": "result", - "value": { - "stringValue": "timeout" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "write" - } - }, - { - "key": "result", - "value": { - "stringValue": "success" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "read" - } - }, - { - "key": "result", - "value": { - "stringValue": "error" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "udf" - } - }, - { - "key": "result", - "value": { - "stringValue": "timeout" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "delete" - } - }, - { - "key": "result", - "value": { - "stringValue": "timeout" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "read" - } - }, - { - "key": "result", - "value": { - "stringValue": "filtered_out" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "read" - } - }, - { - "key": "result", - "value": { - "stringValue": "not_found" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "read" - } - }, - { - "key": "result", - "value": { - "stringValue": "timeout" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "delete" - } - }, - { - "key": "result", - "value": { - "stringValue": "error" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - }, - { - "asInt": "0", - "attributes": [ - { - "key": "type", - "value": { - "stringValue": "delete" - } - }, - { - "key": "result", - "value": { - "stringValue": "filtered_out" - } - } - ], - "startTimeUnixNano": "1657031521609814454", - "timeUnixNano": "1657031536620935803" - } - ], - "isMonotonic": true - }, - "unit": "{transactions}" - } - ], - "scope": { - "name": "otelcol/aerospikereceiver", - "version": "latest" - } - } - ] - } - ] - } - + "resourceMetrics": [ + { + "resource": { + "attributes": [ + { + "key": "aerospike.node.name", + "value": { + "stringValue": "BB9060011AC4202" + } + } + ] + }, + "scopeMetrics": [ + { + "metrics": [ + { + "description": "Number of connections opened and closed to the node", + "name": "aerospike.node.connection.count", + "sum": { + "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", + "dataPoints": [ + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "heartbeat" + } + }, + { + "key": "operation", + "value": { + "stringValue": "close" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "1", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "client" + } + }, + { + "key": "operation", + "value": { + "stringValue": "open" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "fabric" + } + }, + { + "key": "operation", + "value": { + "stringValue": "open" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "heartbeat" + } + }, + { + "key": "operation", + "value": { + "stringValue": "open" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "client" + } + }, + { + "key": "operation", + "value": { + "stringValue": "close" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "fabric" + } + }, + { + "key": "operation", + "value": { + "stringValue": "close" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ], + "isMonotonic": true + }, + "unit": "{connections}" + }, + { + "description": "Current number of open connections to the node", + "name": "aerospike.node.connection.open", + "sum": { + "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", + "dataPoints": [ + { + "asInt": "1", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "client" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "fabric" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "heartbeat" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ] + }, + "unit": "{connections}" + }, + { + "description": "Percentage of the node's memory which is still free", + "gauge": { + "dataPoints": [ + { + "asInt": "53", + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ] + }, + "name": "aerospike.node.memory.free", + "unit": "%" + } + ], + "scope": { + "name": "otelcol/aerospikereceiver", + "version": "latest" + } + } + ] + }, + { + "resource": { + "attributes": [ + { + "key": "aerospike.namespace", + "value": { + "stringValue": "test" + } + }, + { + "key": "aerospike.node.name", + "value": { + "stringValue": "BB9060011AC4202" + } + } + ] + }, + "scopeMetrics": [ + { + "metrics": [ + { + "description": "Minimum percentage of contiguous disk space free to the namespace across all devices", + "gauge": { + "dataPoints": [ + { + "asInt": "99", + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ] + }, + "name": "aerospike.namespace.disk.available", + "unit": "%" + }, + { + "description": "Number of cell coverings for query region queried", + "name": "aerospike.namespace.geojson.region_query_cells", + "sum": { + "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", + "dataPoints": [ + { + "asInt": "0", + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ], + "isMonotonic": true + }, + "unit": "{cells}" + }, + { + "description": "Number of points outside the region.", + "name": "aerospike.namespace.geojson.region_query_false_positive", + "sum": { + "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", + "dataPoints": [ + { + "asInt": "0", + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ], + "isMonotonic": true + }, + "unit": "{points}" + }, + { + "description": "Number of points within the region.", + "name": "aerospike.namespace.geojson.region_query_points", + "sum": { + "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", + "dataPoints": [ + { + "asInt": "0", + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ], + "isMonotonic": true + }, + "unit": "{points}" + }, + { + "description": "Number of geojson queries on the system since the uptime of the node.", + "name": "aerospike.namespace.geojson.region_query_requests", + "sum": { + "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", + "dataPoints": [ + { + "asInt": "0", + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ], + "isMonotonic": true + }, + "unit": "{queries}" + }, + { + "description": "Percentage of the namespace's memory which is still free", + "gauge": { + "dataPoints": [ + { + "asInt": "100", + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ] + }, + "name": "aerospike.namespace.memory.free", + "unit": "%" + }, + { + "description": "Memory currently used by each component of the namespace", + "name": "aerospike.namespace.memory.usage", + "sum": { + "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", + "dataPoints": [ + { + "asInt": "0", + "attributes": [ + { + "key": "component", + "value": { + "stringValue": "secondary_index" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "component", + "value": { + "stringValue": "data" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "component", + "value": { + "stringValue": "set_index" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "component", + "value": { + "stringValue": "index" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ] + }, + "unit": "By" + }, + { + "description": "Number of query operations performed on the namespace", + "name": "aerospike.namespace.query.count", + "sum": { + "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", + "dataPoints": [ + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "udf_background" + } + }, + { + "key": "index", + "value": { + "stringValue": "secondary" + } + }, + { + "key": "result", + "value": { + "stringValue": "complete" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "basic" + } + }, + { + "key": "index", + "value": { + "stringValue": "secondary" + } + }, + { + "key": "result", + "value": { + "stringValue": "complete" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "aggregation" + } + }, + { + "key": "index", + "value": { + "stringValue": "secondary" + } + }, + { + "key": "result", + "value": { + "stringValue": "error" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "udf_background" + } + }, + { + "key": "index", + "value": { + "stringValue": "secondary" + } + }, + { + "key": "result", + "value": { + "stringValue": "error" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "ops_background" + } + }, + { + "key": "index", + "value": { + "stringValue": "secondary" + } + }, + { + "key": "result", + "value": { + "stringValue": "abort" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "ops_background" + } + }, + { + "key": "index", + "value": { + "stringValue": "secondary" + } + }, + { + "key": "result", + "value": { + "stringValue": "complete" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "aggregation" + } + }, + { + "key": "index", + "value": { + "stringValue": "secondary" + } + }, + { + "key": "result", + "value": { + "stringValue": "abort" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "basic" + } + }, + { + "key": "index", + "value": { + "stringValue": "secondary" + } + }, + { + "key": "result", + "value": { + "stringValue": "abort" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "ops_background" + } + }, + { + "key": "index", + "value": { + "stringValue": "secondary" + } + }, + { + "key": "result", + "value": { + "stringValue": "error" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "udf_background" + } + }, + { + "key": "index", + "value": { + "stringValue": "secondary" + } + }, + { + "key": "result", + "value": { + "stringValue": "abort" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "basic" + } + }, + { + "key": "index", + "value": { + "stringValue": "secondary" + } + }, + { + "key": "result", + "value": { + "stringValue": "error" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "aggregation" + } + }, + { + "key": "index", + "value": { + "stringValue": "secondary" + } + }, + { + "key": "result", + "value": { + "stringValue": "complete" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ], + "isMonotonic": true + }, + "unit": "{queries}" + }, + { + "description": "Number of scan operations performed on the namespace", + "name": "aerospike.namespace.scan.count", + "sum": { + "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", + "dataPoints": [ + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "ops_background" + } + }, + { + "key": "result", + "value": { + "stringValue": "abort" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "basic" + } + }, + { + "key": "result", + "value": { + "stringValue": "complete" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "udf_background" + } + }, + { + "key": "result", + "value": { + "stringValue": "abort" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "basic" + } + }, + { + "key": "result", + "value": { + "stringValue": "abort" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "ops_background" + } + }, + { + "key": "result", + "value": { + "stringValue": "error" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "aggregation" + } + }, + { + "key": "result", + "value": { + "stringValue": "abort" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "ops_background" + } + }, + { + "key": "result", + "value": { + "stringValue": "complete" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "udf_background" + } + }, + { + "key": "result", + "value": { + "stringValue": "error" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "basic" + } + }, + { + "key": "result", + "value": { + "stringValue": "error" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "aggregation" + } + }, + { + "key": "result", + "value": { + "stringValue": "error" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "aggregation" + } + }, + { + "key": "result", + "value": { + "stringValue": "complete" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "udf_background" + } + }, + { + "key": "result", + "value": { + "stringValue": "complete" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ], + "isMonotonic": true + }, + "unit": "{scans}" + }, + { + "description": "Number of transactions performed on the namespace", + "name": "aerospike.namespace.transaction.count", + "sum": { + "aggregationTemporality": "AGGREGATION_TEMPORALITY_CUMULATIVE", + "dataPoints": [ + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "udf" + } + }, + { + "key": "result", + "value": { + "stringValue": "filtered_out" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "delete" + } + }, + { + "key": "result", + "value": { + "stringValue": "error" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "delete" + } + }, + { + "key": "result", + "value": { + "stringValue": "not_found" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "udf" + } + }, + { + "key": "result", + "value": { + "stringValue": "error" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "write" + } + }, + { + "key": "result", + "value": { + "stringValue": "timeout" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "read" + } + }, + { + "key": "result", + "value": { + "stringValue": "filtered_out" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "delete" + } + }, + { + "key": "result", + "value": { + "stringValue": "filtered_out" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "read" + } + }, + { + "key": "result", + "value": { + "stringValue": "error" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "read" + } + }, + { + "key": "result", + "value": { + "stringValue": "success" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "read" + } + }, + { + "key": "result", + "value": { + "stringValue": "not_found" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "write" + } + }, + { + "key": "result", + "value": { + "stringValue": "filtered_out" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "delete" + } + }, + { + "key": "result", + "value": { + "stringValue": "timeout" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "read" + } + }, + { + "key": "result", + "value": { + "stringValue": "timeout" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "write" + } + }, + { + "key": "result", + "value": { + "stringValue": "error" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "delete" + } + }, + { + "key": "result", + "value": { + "stringValue": "success" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "write" + } + }, + { + "key": "result", + "value": { + "stringValue": "success" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + }, + { + "asInt": "0", + "attributes": [ + { + "key": "type", + "value": { + "stringValue": "udf" + } + }, + { + "key": "result", + "value": { + "stringValue": "timeout" + } + } + ], + "startTimeUnixNano": "1660328842925289000", + "timeUnixNano": "1660328843530626000" + } + ], + "isMonotonic": true + }, + "unit": "{transactions}" + } + ], + "scope": { + "name": "otelcol/aerospikereceiver", + "version": "latest" + } + } + ] + } + ] +} diff --git a/unreleased/aerospikereceiver-metrics-query.yaml b/unreleased/aerospikereceiver-metrics-query.yaml new file mode 100755 index 000000000000..bfa8051de4b3 --- /dev/null +++ b/unreleased/aerospikereceiver-metrics-query.yaml @@ -0,0 +1,16 @@ +# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix' +change_type: enhancement + +# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver) +component: aerospikereceiver + +# A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`). +note: Add query_count and query_tracked metrics + +# One or more tracking issues related to the change +issues: [13255] + +# (Optional) One or more lines of additional information to render under the primary note. +# These lines will be padded with 2 spaces and then inserted directly into the document. +# Use pipe (|) for multiline entries. +subtext: