metadata

Documentation

Index

• Constants
• Variables
• func MeasurementsToMetric(meas *mongodbatlas.Measurements, buildUnrecognized bool) (*pdata.Metric, error)
• type MetricIntf

Constants

const Type config.Type = "mongoatlasreceiver"

Type is the component type name.

Variables

var A = Attributes

A is an alias for Attributes.

var AttributeAssertType = struct {
	Regular string
	Warning string
	Msg     string
	User    string
}{
	"regular",
	"warning",
	"msg",
	"user",
}

AttributeAssertType are the possible values that the attribute "assert_type" can have.

var AttributeBtreeCounterType = struct {
	Accesses string
	Hits     string
	Misses   string
}{
	"accesses",
	"hits",
	"misses",
}

AttributeBtreeCounterType are the possible values that the attribute "btree_counter_type" can have.

var AttributeCPUState = struct {
	Kernel  string
	User    string
	Nice    string
	Iowait  string
	Irq     string
	Softirq string
	Guest   string
	Steal   string
}{
	"kernel",
	"user",
	"nice",
	"iowait",
	"irq",
	"softirq",
	"guest",
	"steal",
}

AttributeCPUState are the possible values that the attribute "cpu_state" can have.

var AttributeCacheDirection = struct {
	ReadInto    string
	WrittenFrom string
}{
	"read_into",
	"written_from",
}

AttributeCacheDirection are the possible values that the attribute "cache_direction" can have.

var AttributeCacheStatus = struct {
	Dirty string
	Used  string
}{
	"dirty",
	"used",
}

AttributeCacheStatus are the possible values that the attribute "cache_status" can have.

var AttributeClusterRole = struct {
	Primary string
	Replica string
}{
	"primary",
	"replica",
}

AttributeClusterRole are the possible values that the attribute "cluster_role" can have.

var AttributeCursorState = struct {
	TimedOut string
	Open     string
}{
	"timed_out",
	"open",
}

AttributeCursorState are the possible values that the attribute "cursor_state" can have.

var AttributeDirection = struct {
	Receive  string
	Transmit string
}{
	"receive",
	"transmit",
}

AttributeDirection are the possible values that the attribute "direction" can have.

var AttributeDiskDirection = struct {
	Read  string
	Write string
	Total string
}{
	"read",
	"write",
	"total",
}

AttributeDiskDirection are the possible values that the attribute "disk_direction" can have.

var AttributeDiskStatus = struct {
	Free string
	Used string
}{
	"free",
	"used",
}

AttributeDiskStatus are the possible values that the attribute "disk_status" can have.

var AttributeDocumentStatus = struct {
	Returned string
	Inserted string
	Updated  string
	Deleted  string
}{
	"returned",
	"inserted",
	"updated",
	"deleted",
}

AttributeDocumentStatus are the possible values that the attribute "document_status" can have.

var AttributeExecutionType = struct {
	Reads    string
	Writes   string
	Commands string
}{
	"reads",
	"writes",
	"commands",
}

AttributeExecutionType are the possible values that the attribute "execution_type" can have.

var AttributeGlobalLockState = struct {
	CurrentQueueTotal   string
	CurrentQueueReaders string
	CurrentQueueWriters string
}{
	"current_queue_total",
	"current_queue_readers",
	"current_queue_writers",
}

AttributeGlobalLockState are the possible values that the attribute "global_lock_state" can have.

var AttributeMemoryIssueType = struct {
	ExtraInfo                 string
	GlobalAccessesNotInMemory string
	ExceptionsThrown          string
}{
	"extra_info",
	"global_accesses_not_in_memory",
	"exceptions_thrown",
}

AttributeMemoryIssueType are the possible values that the attribute "memory_issue_type" can have.

var AttributeMemoryState = struct {
	Resident string
	Virtual  string
	Mapped   string
	Computed string
}{
	"resident",
	"virtual",
	"mapped",
	"computed",
}

AttributeMemoryState are the possible values that the attribute "memory_state" can have.

var AttributeObjectType = struct {
	Collection string
	Index      string
	Extent     string
	Object     string
	View       string
	Storage    string
	Data       string
}{
	"collection",
	"index",
	"extent",
	"object",
	"view",
	"storage",
	"data",
}

AttributeObjectType are the possible values that the attribute "object_type" can have.

var AttributeOperation = struct {
	Cmd     string
	Query   string
	Update  string
	Delete  string
	Getmore string
	Insert  string
}{
	"cmd",
	"query",
	"update",
	"delete",
	"getmore",
	"insert",
}

AttributeOperation are the possible values that the attribute "operation" can have.

var AttributeOplogType = struct {
	SlaveLagMasterTime string
	MasterTime         string
	MasterLagTimeDiff  string
}{
	"slave_lag_master_time",
	"master_time",
	"master_lag_time_diff",
}

AttributeOplogType are the possible values that the attribute "oplog_type" can have.

var AttributeScannedType = struct {
	IndexItems string
	Objects    string
}{
	"index_items",
	"objects",
}

AttributeScannedType are the possible values that the attribute "scanned_type" can have.

var AttributeStorageStatus = struct {
	Total            string
	DataSize         string
	IndexSize        string
	DataSizeWoSystem string
}{
	"total",
	"data_size",
	"index_size",
	"data_size_wo_system",
}

AttributeStorageStatus are the possible values that the attribute "storage_status" can have.

var AttributeTicketType = struct {
	AvailableReads  string
	AvailableWrites string
}{
	"available_reads",
	"available_writes",
}

AttributeTicketType are the possible values that the attribute "ticket_type" can have.

var Attributes = struct {
	// AssertType (MongoDB assertion type)
	AssertType string
	// BtreeCounterType (Database index effectiveness)
	BtreeCounterType string
	// CacheDirection (Whether read into or written from)
	CacheDirection string
	// CacheStatus (Cache status)
	CacheStatus string
	// ClusterRole (Whether process is acting as replica or primary)
	ClusterRole string
	// CPUState (CPU state)
	CPUState string
	// CursorState (Whether cursor is open or timed out)
	CursorState string
	// Direction (Network traffic direction)
	Direction string
	// DiskDirection (Measurement type for disk operation)
	DiskDirection string
	// DiskStatus (Disk measurement type)
	DiskStatus string
	// DocumentStatus (Status of documents in the database)
	DocumentStatus string
	// ExecutionType (Type of command)
	ExecutionType string
	// GlobalLockState (Which queue is locked)
	GlobalLockState string
	// MemoryIssueType (Type of memory issue encountered)
	MemoryIssueType string
	// MemoryState (Memory usage type)
	MemoryState string
	// ObjectType (MongoDB object type)
	ObjectType string
	// Operation (Type of database operation)
	Operation string
	// OplogType (Oplog type)
	OplogType string
	// ScannedType (Objects or indexes scanned during query)
	ScannedType string
	// StorageStatus (Views on database size)
	StorageStatus string
	// TicketType (Type of ticket available)
	TicketType string
}{
	"assert_type",
	"btree_counter_type",
	"cache_direction",
	"cache_status",
	"cluster_role",
	"cpu_state",
	"cursor_state",
	"direction",
	"disk_direction",
	"disk_status",
	"document_status",
	"execution_type",
	"global_lock_state",
	"memory_issue_type",
	"memory_state",
	"object_type",
	"operation",
	"oplog_type",
	"scanned_type",
	"storage_status",
	"ticket_type",
}

Attributes contains the possible metric attributes that can be used.

var M = Metrics

M contains a set of methods for each metric that help with manipulating those metrics. M is an alias for Metrics

var Metrics = &metricStruct{
	&metricImpl{
		"mongodbatlas.db.counts",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.db.counts")
			metric.SetDescription("Database feature size")
			metric.SetUnit("{objects}")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.db.size",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.db.size")
			metric.SetDescription("Database feature size")
			metric.SetUnit("By")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.disk.partition.iops.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.disk.partition.iops.average")
			metric.SetDescription("Disk partition iops")
			metric.SetUnit("{ops}/s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.disk.partition.iops.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.disk.partition.iops.max")
			metric.SetDescription("Disk partition iops")
			metric.SetUnit("{ops}/s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.disk.partition.latency.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.disk.partition.latency.average")
			metric.SetDescription("Disk partition latency")
			metric.SetUnit("ms")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.disk.partition.latency.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.disk.partition.latency.max")
			metric.SetDescription("Disk partition latency")
			metric.SetUnit("ms")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.disk.partition.space.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.disk.partition.space.average")
			metric.SetDescription("Disk partition space")
			metric.SetUnit("By")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.disk.partition.space.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.disk.partition.space.max")
			metric.SetDescription("Disk partition space")
			metric.SetUnit("By")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.disk.partition.usage.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.disk.partition.usage.average")
			metric.SetDescription("Disk partition usage (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.disk.partition.usage.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.disk.partition.usage.max")
			metric.SetDescription("Disk partition usage (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.disk.partition.utilization.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.disk.partition.utilization.average")
			metric.SetDescription("Disk partition utilization (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.disk.partition.utilization.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.disk.partition.utilization.max")
			metric.SetDescription("Disk partition utilization (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.asserts",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.asserts")
			metric.SetDescription("Number of assertions per second")
			metric.SetUnit("{assertions}/s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.background_flush",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.background_flush")
			metric.SetDescription("Amount of data flushed in the background")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.cache.io",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.cache.io")
			metric.SetDescription("Cache throughput (per second)")
			metric.SetUnit("By")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.cache.size",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.cache.size")
			metric.SetDescription("Cache sizes")
			metric.SetUnit("By")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(false)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mongodbatlas.process.connections",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.connections")
			metric.SetDescription("Number of current connections")
			metric.SetUnit("{connections}")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(false)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mongodbatlas.process.cpu.children.normalized.usage.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.cpu.children.normalized.usage.average")
			metric.SetDescription("CPU Usage for child processes, normalized to pct")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.cpu.children.normalized.usage.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.cpu.children.normalized.usage.max")
			metric.SetDescription("CPU Usage for child processes, normalized to pct")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.cpu.children.usage.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.cpu.children.usage.average")
			metric.SetDescription("CPU Usage for child processes (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.cpu.children.usage.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.cpu.children.usage.max")
			metric.SetDescription("CPU Usage for child processes (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.cpu.normalized.usage.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.cpu.normalized.usage.average")
			metric.SetDescription("CPU Usage, normalized to pct")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.cpu.normalized.usage.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.cpu.normalized.usage.max")
			metric.SetDescription("CPU Usage, normalized to pct")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.cpu.usage.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.cpu.usage.average")
			metric.SetDescription("CPU Usage (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.cpu.usage.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.cpu.usage.max")
			metric.SetDescription("CPU Usage (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.cursors",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.cursors")
			metric.SetDescription("Number of cursors")
			metric.SetUnit("{cursors}")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.db.document.rate",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.db.document.rate")
			metric.SetDescription("Document access rates")
			metric.SetUnit("{documents}/s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.db.operations.rate",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.db.operations.rate")
			metric.SetDescription("DB Operation Rates")
			metric.SetUnit("{operations}/s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.db.operations.time",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.db.operations.time")
			metric.SetDescription("DB Operation Times")
			metric.SetUnit("ms")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mongodbatlas.process.db.query_executor.scanned",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.db.query_executor.scanned")
			metric.SetDescription("Scanned objects")
			metric.SetUnit("{objects}/s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.db.query_targeting.scanned_per_returned",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.db.query_targeting.scanned_per_returned")
			metric.SetDescription("Scanned objects per returned")
			metric.SetUnit("{scanned}/{returned}")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.db.storage",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.db.storage")
			metric.SetDescription("Storage used by the database")
			metric.SetUnit("By")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.fts.cpu.usage",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.fts.cpu.usage")
			metric.SetDescription("Full text search CPU (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.global_lock",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.global_lock")
			metric.SetDescription("Number and status of locks")
			metric.SetUnit("{locks}")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.index.btree_miss_ratio",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.index.btree_miss_ratio")
			metric.SetDescription("Index miss ratio (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.index.counters",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.index.counters")
			metric.SetDescription("Indexes")
			metric.SetUnit("{indexes}")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.journaling.commits",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.journaling.commits")
			metric.SetDescription("Journaling commits")
			metric.SetUnit("{commits}")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.journaling.data_files",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.journaling.data_files")
			metric.SetDescription("Data file sizes")
			metric.SetUnit("MiBy")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.journaling.written",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.journaling.written")
			metric.SetDescription("Journals written")
			metric.SetUnit("MiBy")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.memory.usage",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.memory.usage")
			metric.SetDescription("Memory Usage")
			metric.SetUnit("By")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.network.io",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.network.io")
			metric.SetDescription("Network IO")
			metric.SetUnit("By/s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.network.requests",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.network.requests")
			metric.SetDescription("Network requests")
			metric.SetUnit("{requests}")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mongodbatlas.process.oplog.rate",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.oplog.rate")
			metric.SetDescription("Execution rate by operation")
			metric.SetUnit("GiBy/h")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.oplog.time",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.oplog.time")
			metric.SetDescription("Execution time by operation")
			metric.SetUnit("s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.page_faults",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.page_faults")
			metric.SetDescription("Page faults")
			metric.SetUnit("{faults}/s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.restarts",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.restarts")
			metric.SetDescription("Restarts in last hour")
			metric.SetUnit("{restarts}/h")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.process.tickets",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.process.tickets")
			metric.SetDescription("Tickets")
			metric.SetUnit("{tickets}")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.cpu.normalized.usage.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.cpu.normalized.usage.average")
			metric.SetDescription("System CPU Normalized to pct")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.cpu.normalized.usage.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.cpu.normalized.usage.max")
			metric.SetDescription("System CPU Normalized to pct")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.cpu.usage.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.cpu.usage.average")
			metric.SetDescription("System CPU Usage (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.cpu.usage.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.cpu.usage.max")
			metric.SetDescription("System CPU Usage (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.fts.cpu.normalized.usage",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.fts.cpu.normalized.usage")
			metric.SetDescription("Full text search disk usage (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.fts.cpu.usage",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.fts.cpu.usage")
			metric.SetDescription("Full-text search (%)")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.fts.disk.used",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.fts.disk.used")
			metric.SetDescription("Full text search disk usage")
			metric.SetUnit("By")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.fts.memory.usage",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.fts.memory.usage")
			metric.SetDescription("Full-text search")
			metric.SetUnit("MiBy")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mongodbatlas.system.memory.usage.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.memory.usage.average")
			metric.SetDescription("System Memory Usage")
			metric.SetUnit("KiBy")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.memory.usage.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.memory.usage.max")
			metric.SetDescription("System Memory Usage")
			metric.SetUnit("KiBy")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.network.io.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.network.io.average")
			metric.SetDescription("System Network IO")
			metric.SetUnit("By/s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.network.io.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.network.io.max")
			metric.SetDescription("System Network IO")
			metric.SetUnit("By/s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.paging.io.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.paging.io.average")
			metric.SetDescription("Swap IO")
			metric.SetUnit("{pages}/s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.paging.io.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.paging.io.max")
			metric.SetDescription("Swap IO")
			metric.SetUnit("{pages}/s")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.paging.usage.average",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.paging.usage.average")
			metric.SetDescription("Swap usage")
			metric.SetUnit("KiBy")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
	&metricImpl{
		"mongodbatlas.system.paging.usage.max",
		func(metric pdata.Metric) {
			metric.SetName("mongodbatlas.system.paging.usage.max")
			metric.SetDescription("Swap usage")
			metric.SetUnit("KiBy")
			metric.SetDataType(pdata.MetricDataTypeGauge)
		},
	},
}

Metrics contains a set of methods for each metric that help with manipulating those metrics.

Functions

func MeasurementsToMetric

func MeasurementsToMetric(meas *mongodbatlas.Measurements, buildUnrecognized bool) (*pdata.Metric, error)

Types

type MetricIntf

type MetricIntf interface {
	Name() string
	New() pdata.Metric
	Init(metric pdata.Metric)
}

MetricIntf is an interface to generically interact with generated metric.