metadata

Documentation

Index

• Constants
• Variables
• type MetricIntf

Constants

const Type config.Type = "mysqlreceiver"

Type is the component type name.

Variables

var L = Labels

L contains the possible metric labels that can be used. L is an alias for Labels.

var LabelBufferPoolOperations = struct {
	ReadAheadRnd     string
	ReadAhead        string
	ReadAheadEvicted string
	ReadRequests     string
	Reads            string
	WaitFree         string
	WriteRequests    string
}{
	"read_ahead_rnd",
	"read_ahead",
	"read_ahead_evicted",
	"read_requests",
	"reads",
	"wait_free",
	"write_requests",
}

LabelBufferPoolOperations are the possible values that the label "buffer_pool_operations" can have.

var LabelBufferPoolPages = struct {
	Data    string
	Dirty   string
	Flushed string
	Free    string
	Misc    string
	Total   string
}{
	"data",
	"dirty",
	"flushed",
	"free",
	"misc",
	"total",
}

LabelBufferPoolPages are the possible values that the label "buffer_pool_pages" can have.

var LabelBufferPoolSize = struct {
	Data  string
	Dirty string
	Total string
}{
	"data",
	"dirty",
	"total",
}

LabelBufferPoolSize are the possible values that the label "buffer_pool_size" can have.

var LabelCommand = struct {
	Execute      string
	Close        string
	Fetch        string
	Prepare      string
	Reset        string
	SendLongData string
}{
	"execute",
	"close",
	"fetch",
	"prepare",
	"reset",
	"send_long_data",
}

LabelCommand are the possible values that the label "command" can have.

var LabelDoubleWrites = struct {
	PagesWritten string
	Writes       string
}{
	"pages_written",
	"writes",
}

LabelDoubleWrites are the possible values that the label "double_writes" can have.

var LabelHandler = struct {
	Commit            string
	Delete            string
	Discover          string
	ExternalLock      string
	MrrInit           string
	Prepare           string
	ReadFirst         string
	ReadKey           string
	ReadLast          string
	ReadNext          string
	ReadPrev          string
	ReadRnd           string
	ReadRndNext       string
	Rollback          string
	Savepoint         string
	SavepointRollback string
	Update            string
	Write             string
}{
	"commit",
	"delete",
	"discover",
	"external_lock",
	"mrr_init",
	"prepare",
	"read_first",
	"read_key",
	"read_last",
	"read_next",
	"read_prev",
	"read_rnd",
	"read_rnd_next",
	"rollback",
	"savepoint",
	"savepoint_rollback",
	"update",
	"write",
}

LabelHandler are the possible values that the label "handler" can have.

var LabelLocks = struct {
	Immediate string
	Waited    string
}{
	"immediate",
	"waited",
}

LabelLocks are the possible values that the label "locks" can have.

var LabelLogOperations = struct {
	Waits         string
	WriteRequests string
	Writes        string
}{
	"waits",
	"write_requests",
	"writes",
}

LabelLogOperations are the possible values that the label "log_operations" can have.

var LabelOperations = struct {
	Fsyncs string
	Reads  string
	Writes string
}{
	"fsyncs",
	"reads",
	"writes",
}

LabelOperations are the possible values that the label "operations" can have.

var LabelPageOperations = struct {
	Created string
	Read    string
	Written string
}{
	"created",
	"read",
	"written",
}

LabelPageOperations are the possible values that the label "page_operations" can have.

var LabelRowLocks = struct {
	Waits string
	Time  string
}{
	"waits",
	"time",
}

LabelRowLocks are the possible values that the label "row_locks" can have.

var LabelRowOperations = struct {
	Deleted  string
	Inserted string
	Read     string
	Updated  string
}{
	"deleted",
	"inserted",
	"read",
	"updated",
}

LabelRowOperations are the possible values that the label "row_operations" can have.

var LabelSorts = struct {
	MergePasses string
	Range       string
	Rows        string
	Scan        string
}{
	"merge_passes",
	"range",
	"rows",
	"scan",
}

LabelSorts are the possible values that the label "sorts" can have.

var LabelThreads = struct {
	Cached    string
	Connected string
	Created   string
	Running   string
}{
	"cached",
	"connected",
	"created",
	"running",
}

LabelThreads are the possible values that the label "threads" can have.

var Labels = struct {
	// BufferPoolOperations (The buffer pool operations types.)
	BufferPoolOperations string
	// BufferPoolPages (The buffer pool pages types.)
	BufferPoolPages string
	// BufferPoolSize (The buffer pool size types.)
	BufferPoolSize string
	// Command (The command types.)
	Command string
	// DoubleWrites (The doublewrite types.)
	DoubleWrites string
	// Handler (The handler types.)
	Handler string
	// Locks (The table locks type.)
	Locks string
	// LogOperations (The log operation types.)
	LogOperations string
	// Operations (The operation types.)
	Operations string
	// PageOperations (The page operation types.)
	PageOperations string
	// RowLocks (The row lock type.)
	RowLocks string
	// RowOperations (The row operation type.)
	RowOperations string
	// Sorts (The sort count type.)
	Sorts string
	// Threads (The thread count type.)
	Threads string
}{
	"operation",
	"kind",
	"kind",
	"command",
	"kind",
	"kind",
	"kind",
	"operation",
	"operation",
	"operation",
	"kind",
	"operation",
	"kind",
	"kind",
}

Labels contains the possible metric labels 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{
		"mysql.buffer_pool_operations",
		func(metric pdata.Metric) {
			metric.SetName("mysql.buffer_pool_operations")
			metric.SetDescription("The number of operations on the InnoDB buffer pool.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.buffer_pool_pages",
		func(metric pdata.Metric) {
			metric.SetName("mysql.buffer_pool_pages")
			metric.SetDescription("The number of pages in the InnoDB buffer pool.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(false)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.buffer_pool_size",
		func(metric pdata.Metric) {
			metric.SetName("mysql.buffer_pool_size")
			metric.SetDescription("The number of bytes in the InnoDB buffer pool.")
			metric.SetUnit("By")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(false)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.commands",
		func(metric pdata.Metric) {
			metric.SetName("mysql.commands")
			metric.SetDescription("The number of times each type of command has been executed.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.double_writes",
		func(metric pdata.Metric) {
			metric.SetName("mysql.double_writes")
			metric.SetDescription("The number of writes to the InnoDB doublewrite buffer.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.handlers",
		func(metric pdata.Metric) {
			metric.SetName("mysql.handlers")
			metric.SetDescription("The number of requests to various MySQL handlers.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.locks",
		func(metric pdata.Metric) {
			metric.SetName("mysql.locks")
			metric.SetDescription("The number of MySQL locks.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.log_operations",
		func(metric pdata.Metric) {
			metric.SetName("mysql.log_operations")
			metric.SetDescription("The number of InndoDB log operations.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.operations",
		func(metric pdata.Metric) {
			metric.SetName("mysql.operations")
			metric.SetDescription("The number of InndoDB operations.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.page_operations",
		func(metric pdata.Metric) {
			metric.SetName("mysql.page_operations")
			metric.SetDescription("The number of InndoDB page operations.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.row_locks",
		func(metric pdata.Metric) {
			metric.SetName("mysql.row_locks")
			metric.SetDescription("The number of InndoDB row locks.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.row_operations",
		func(metric pdata.Metric) {
			metric.SetName("mysql.row_operations")
			metric.SetDescription("The number of InndoDB row operations.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.sorts",
		func(metric pdata.Metric) {
			metric.SetName("mysql.sorts")
			metric.SetDescription("The number of MySQL sorts.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(true)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
	&metricImpl{
		"mysql.threads",
		func(metric pdata.Metric) {
			metric.SetName("mysql.threads")
			metric.SetDescription("The state of MySQL threads.")
			metric.SetUnit("1")
			metric.SetDataType(pdata.MetricDataTypeSum)
			metric.Sum().SetIsMonotonic(false)
			metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative)
		},
	},
}

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

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.