probe

const (

	// CassandraParamAddress : (mandatory) the address of the jolokia bridge to cassandra server to gather metric from (string)
	CassandraParamAddress = "address"
	// CassandraParamTimeout (optional) : duration before the HTTP request times out (default value: 0)(`time.Duration`)
	CassandraParamTimeout = "timeout"

	// CassandraResultHeapMemoryInit : Amount of heap memory in bytes that the JVM initially requests from the OS (float64)
	CassandraResultHeapMemoryInit = "heap-memory-init"
	// CassandraResultHeapMemoryCommitted : Amount of heap memory in bytes that is committed for the JVM to use (float64)
	CassandraResultHeapMemoryCommitted = "heap-memory-committed"
	// CassandraResultHeapMemoryMax : Maximum amount of heap memory in bytes that can be used for memory management (float64)
	CassandraResultHeapMemoryMax = "heap-memory-max"
	// CassandraResultHeapMemoryUsed : Amount of used heap memory in bytes (float64)
	CassandraResultHeapMemoryUsed = "heap-memory-used"
	// CassandraResultNonHeapMemoryInit : Amount of non-heap memory in bytes that the JVM initially requests from the OS (float64)
	CassandraResultNonHeapMemoryInit = "nonheap-memory-init"
	// CassandraResultNonHeapMemoryCommitted : Amount of non-heap memory in bytes that is committed for the JVM to use (float64)
	CassandraResultNonHeapMemoryCommitted = "nonheap-memory-committed"
	// CassandraResultNonHeapMemoryMax : Maximum amount of non-heap memory in bytes that can be used for memory management (float64)
	CassandraResultNonHeapMemoryMax = "nonheap-memory-max"
	// CassandraResultNonHeapMemoryUsed : Amount of used non-heap memory in bytes (float64)
	CassandraResultNonHeapMemoryUsed = "nonheap-memory-used"
	// CassandraResultConnectedClients : Number of clients connected to this nodes native protocol server (float64)
	CassandraResultConnectedClients = "connected-clients"
	// CassandraResultKeyCacheHits : Total number of cache hits for partition to sstable offsets (float64)
	CassandraResultKeyCacheHits = "key-cache-hits"
	// CassandraResultKeyCacheRequests : Total number of cache requests for partition to sstable offsets (float64)
	CassandraResultKeyCacheRequests = "key-cache-requests"
	// CassandraResultKeyCacheEntries : Total number of cache entries for partition to sstable offsets (float64)
	CassandraResultKeyCacheEntries = "key-cache-entries"
	// CassandraResultKeyCacheSize : Total size of occupied cache, in bytes, for partition to sstable offsets (float64)
	CassandraResultKeyCacheSize = "key-cache-size"
	// CassandraResultKeyCacheCapacity : Cache capacity, in bytes, for partition to sstable offsets (float64)
	CassandraResultKeyCacheCapacity = "key-cache-capacity"
	// CassandraResultRowCacheHits : Total number of cache hits for rows kept in memory (float64)
	CassandraResultRowCacheHits = "row-cache-hits"
	// CassandraResultRowCacheRequests : Total number of cache requests for rows kept in memory (float64)
	CassandraResultRowCacheRequests = "row-cache-requests"
	// CassandraResultRowCacheEntries : Total number of cache entries for rows kept in memory (float64)
	CassandraResultRowCacheEntries = "row-cache-entries"
	// CassandraResultRowCacheSize : Total size of occupied cache, in bytes, for rows kept in memory (float64)
	CassandraResultRowCacheSize = "row-cache-size"
	// CassandraResultRowCacheCapacity : Cache capacity, in bytes, for rows kept in memory (float64)
	CassandraResultRowCacheCapacity = "row-cache-capacity"
	// CassandraResultReadTotalLatency : Total read latency since starting (float64)
	CassandraResultReadTotalLatency = "read-totallatency"
	// CassandraResultWriteTotalLatency : Total write latency since starting (float64)
	CassandraResultWriteTotalLatency = "write-totallatency"
	// CassandraResultReadTimeouts : Number of timeouts encountered during read (float64)
	CassandraResultReadTimeouts = "read-timeouts"
	// CassandraResultWriteTimeouts : Number of timeouts encountered during write (float64)
	CassandraResultWriteTimeouts = "write-timeouts"
	// CassandraResultReadUnavailables : Number of unavailable exceptions  encountered during read (float64)
	CassandraResultReadUnavailables = "read-unavailables"
	// CassandraResultWriteUnavailables : Number of unavailable exceptions  encountered during write (float64)
	CassandraResultWriteUnavailables = "write-unavailables"
	// CassandraResultReadFailures : Number of failures  encountered during read (float64)
	CassandraResultReadFailures = "read-failures"
	// CassandraResultWriteFailures : Number of failures  encountered during write (float64)
	CassandraResultWriteFailures = "write-failures"
	// CassandraResultCommitLogPendingTasks : Number of commit log messages written but yet to be fsync’d (float64)
	CassandraResultCommitLogPendingTasks = "commitlog-pendingtasks"
	// CassandraResultCommitLogTotalCommitLogSize : Current size, in bytes, used by all the commit log segments (float64)
	CassandraResultCommitLogTotalCommitLogSize = "commitlog-totalsize"
	// CassandraResultCompactionCompletedTasks : Number of completed compactions since server [re]start (float64)
	CassandraResultCompactionCompletedTasks = "compaction-completedtasks"
	// CassandraResultCompactionPendingTasks : Estimated number of compactions remaining to perform (float64)
	CassandraResultCompactionPendingTasks = "compaction-pendingtasks"
	// CassandraResultCompactionBytesCompacted : Total number of bytes compacted since server [re]start (float64)
	CassandraResultCompactionBytesCompacted = "compaction-bytescompacted"
	// CassandraResultStorageLoad : Size, in bytes, of the on disk data size this node manages (float64)
	CassandraResultStorageLoad = "storage-load"
	// CassandraResultStorageExceptions : Number of internal exceptions caught (float64)
	CassandraResultStorageExceptions = "storage-exceptions"
	// CassandraResultTPCompactionExecutorActiveTasks : Number of tasks being actively worked on Compactions (float64)
	CassandraResultTPCompactionExecutorActiveTasks = "tp-compactionexecutor-activetasks"
	// CassandraResultTPAntiEntropyStageActiveTasks : Number of tasks being actively worked on Builds merkle tree for repairs (float64)
	CassandraResultTPAntiEntropyStageActiveTasks = "tp-antientropystage-activetasks"
	// CassandraResultTPCounterMutationStagePendingTasks : Number of queued tasks queued up on counter writes (float64)
	CassandraResultTPCounterMutationStagePendingTasks = "tp-countermutationstage-pendingtasks"
	// CassandraResultTPCounterMutationStageCurrentlyBlockedTasks : Number of tasks that are currently blocked due to queue saturation but on retry will become unblocked on counter writes (float64)
	CassandraResultTPCounterMutationStageCurrentlyBlockedTasks = "tp-countermutationstage-currentlyblockedtasks"
	// CassandraResultTPMutationStagePendingTasks : Number of queued tasks queued up on all other writes (float64)
	CassandraResultTPMutationStagePendingTasks = "tp-mutationstage-pendingtasks"
	// CassandraResultTPMutationStageCurrentlyBlockedTasks : Number of tasks that are currently blocked due to queue saturation but on retry will become unblocked on all other writes (float64)
	CassandraResultTPMutationStageCurrentlyBlockedTasks = "tp-mutationstage-currentlyblockedtasks"
	// CassandraResultTPReadRepairStagePendingTasks : Number of queued tasks queued up on ReadRepair (float64)
	CassandraResultTPReadRepairStagePendingTasks = "tp-readrepairstage-pendingtasks"
	// CassandraResultTPReadRepairStageCurrentlyBlockedTasks : Number of tasks that are currently blocked due to queue saturation but on retry will become unblocked on ReadRepair (float64)
	CassandraResultTPReadRepairStageCurrentlyBlockedTasks = "tp-readrepairstage-currentlyblockedtasks"
	// CassandraResultTPReadStagePendingTasks : Number of queued tasks queued up on Local reads (float64)
	CassandraResultTPReadStagePendingTasks = "tp-readstage-pendingtasks"
	// CassandraResultTPReadStageCurrentlyBlockedTasks : Number of tasks that are currently blocked due to queue saturation but on retry will become unblocked on Local read (float64)
	CassandraResultTPReadStageCurrentlyBlockedTasks = "tp-readstage-currentlyblockedtasks"
	// CassandraResultTPRequestResponseStagePendingTasks : Number of queued tasks queued up on Coordinator requests to the cluster (float64)
	CassandraResultTPRequestResponseStagePendingTasks = "tp-requestresponsestage-pendingtasks"
	// CassandraResultTPRequestResponseStageCurrentlyBlockedTasks : Number of tasks that are currently blocked due to queue saturation but on retry will become unblocked on Coordinator requests to the cluster (float64)
	CassandraResultTPRequestResponseStageCurrentlyBlockedTasks = "tp-requestresponsestage-currentlyblockedtasks"
	// CassandraResultsTableLiveDiskSpaceUsed : Disk space used by SSTables belonging to this table (in bytes) (float64)
	CassandraResultsTableLiveDiskSpaceUsed = "table-livediskspaceused"
	// CassandraResultsTableTotalDiskSpaceUsed : Total disk space used by SSTables belonging to this table, including obsolete ones waiting to be GC’d (float64)
	CassandraResultsTableTotalDiskSpaceUsed = "table-totaldiskspaceused"
	// CassandraResultsTableReadLatency : Local read latency for this keyspace (float64)
	CassandraResultsTableReadLatency = "table-readlatency"
	// CassandraResultsTableCoordinatorReadLatency : Coordinator read latency for this keyspace (float64)
	CassandraResultsTableCoordinatorReadLatency = "table-coordinatorreadlatency"
	// CassandraResultsTableWriteLatency : Local write latency for this keyspace (float64)
	CassandraResultsTableWriteLatency = "table-writelatency"
	// CassandraResultsTableReadTotalLatency : Local read latency for this keyspace since starting (float64)
	CassandraResultsTableReadTotalLatency = "table-readtotallatency"
	// CassandraResultsTableWriteTotalLatency : Local write latency for this keyspace since starting (float64)
	CassandraResultsTableWriteTotalLatency = "table-writetotallatency"

	// CassandraTagKeyspace : The keyspace of the metric, e.g. "system"
	CassandraTagKeyspace = "keyspace"
)

const (
	// ChecksumHashCRC32 designates an IEEE 802.3 CRC-32 checksum
	ChecksumHashCRC32 = "crc32"
	// ChecksumHashMD5 designates an MD5 checksum
	ChecksumHashMD5 = "md5"
	// ChecksumHashSHA1 designates a SHA-1 checksum
	ChecksumHashSHA1 = "sha1"
	// ChecksumHashSHA256 designates a SHA-256 checksum
	ChecksumHashSHA256 = "sha256"
)

const (

	// ChecksumParamPath : (mandatory) The path of the file to check. (string)
	ChecksumParamPath = "path"
	// ChecksumParamHash : The hash algorithm to use. One of "crc32" (default), "md5", "sha1", "sha256". (string)
	ChecksumParamHash = "hash"

	// ChecksumResultChecksum : The result of a checksum as a hexadecimal string. (string)
	ChecksumResultChecksum = "checksum"

	// ChecksumTagPath : The path of the file that was checked.
	ChecksumTagPath = "path"
)

const (

	// CPUParamPerCPU : (optional, default `true`) set to `false` to collect utilization % averaged over all CPUs/cores (`bool`)
	CPUParamPerCPU = "per-cpu"
	// CPUParamInterval : (optional, default 1 second) interval over which CPU utilization is calculated
	CPUParamInterval = "interval"

	// CPUResultBusy :  % of time spent running (sum of all "non-idle" times) (`float32`)
	CPUResultBusy = "busy"
	// CPUResultIdle : % of time spent idle (`float32`)
	CPUResultIdle = "idle"
	// CPUResultUser : % of time spent in user mode (`float32`)
	CPUResultUser = "user"
	// CPUResultSystem : % of time spent in system mode, which is the time spent executing kernel code (`float32`)
	CPUResultSystem = "system"
	// CPUResultNice : % of time spent in user mode with low priority (nice) (`float32`)
	CPUResultNice = "nice"
	// CPUResultIowait : % of time waiting for I/O to complete (`float32`)
	CPUResultIowait = "iowait"
	// CPUResultIrq : % of time servicing interrupts (`float32`)
	CPUResultIrq = "irq"
	// CPUResultSoftirq : % of time servicing softirqs (`float32`)
	CPUResultSoftirq = "softirq"

	// CPUTagCPU : name of the CPU result, "all" for average over all CPUs/cores
	CPUTagCPU = "cpu"
)

const (

	// DiskIOParamInterval : (optional, default 1 second) interval over which disk utilization is calculated
	DiskIOParamInterval = "interval"

	// DiskIOResultIops : Average I/O operations per second (`float32`)
	DiskIOResultIops = "iops"
	// DiskIOResultBytesRead : Average bytes read per second (`float32`)
	DiskIOResultBytesRead = "bytes-read"
	// DiskIOResultBytesWritten : Average bytes written per second (`float32`)
	DiskIOResultBytesWritten = "bytes-written"
	// DiskIOResultLatency : Average time for I/O requests issued to the device to be served, calculated as the time spent
	// doing I/O divided by the # of Iops serverd during the interval (`time.Duration`)
	DiskIOResultLatency = "latency"

	// DiskIOTagDevice : The name of the device, e.g. "sda"
	DiskIOTagDevice = "device"
)

const (

	// DiskUsageParamInterval : (optional, default 1 second) interval over which disk utilization is calculated
	DiskUsageParamInterval = "interval"

	// DiskUsageResultFree : Free space on the disk, in bytes (`uint64`)
	DiskUsageResultFree = "free"
	// DiskUsageResultUsed : Used space on the disk, in bytes (`uint64`)
	DiskUsageResultUsed = "used"
	// DiskUsageResultUsedPercent : Percentage of disk space left, `free / (free + used)` (`float32`)
	DiskUsageResultUsedPercent = "used-percent"
	// DiskUsageResultInodesFree : Number of free inodes on the disk (`uint64`)
	DiskUsageResultInodesFree = "inodes-free"
	// DiskUsageResultInodesUsed : Number of used inodes on the disk (`uint64`)
	DiskUsageResultInodesUsed = "inodes-used"
	// DiskUsageResultInodesUsedPercent : Percentage of inodes left, `free / (free + used)` (`float32`)
	DiskUsageResultInodesUsedPercent = "inodes-used-percent"

	// DiskUsageTagPath : The mount point of the disk, e.g. `"/"`
	DiskUsageTagPath = "path"
)

const (

	// DockerParamAddress : Docker host (`string`)
	DockerParamAddress = "address"

	// DockerResultContainerCountCreated : the number of container with state *created* in the Docker daemon (state is a tag) (`int64`)
	DockerResultContainerCountCreated = "container-count-created"
	// DockerResultContainerCountRunning : the number of container with state *running* in the Docker daemon (state is a tag) (`int64`)
	DockerResultContainerCountRunning = "container-count-running"
	// DockerResultContainerCountPaused : the number of container with state *paused* in the Docker daemon (state is a tag) (`int64`)
	DockerResultContainerCountPaused = "container-count-paused"
	// DockerResultContainerCountRestarting : the number of container with state *restarting* in the Docker daemon (state is a tag) (`int64`)
	DockerResultContainerCountRestarting = "container-count-restarting"
	// DockerResultContainerCountRemoving : the number of container with state *removing* in the Docker daemon (state is a tag) (`int64`)
	DockerResultContainerCountRemoving = "container-count-removing"
	// DockerResultContainerCountExited : the number of container with state *exited* in the Docker daemon (state is a tag) (`int64`)
	DockerResultContainerCountExited = "container-count-exited"
	// DockerResultContainerCountDead : the number of container with state *dead* in the Docker daemon (state is a tag) (`int64`)
	DockerResultContainerCountDead = "container-count-dead"
	// DockerResultContainerCPUTotalUsage : Total CPU time consumed (container name is a tag) (`int64`)
	DockerResultContainerCPUTotalUsage = "cpu-totalusage"
	// DockerResultContainerMemorylUsage : current res_counter usage for memory (container name is a tag) (`float64`)
	DockerResultContainerMemorylUsage = "mem-usage"
	// DockerResultContainerNetworkReceived : Bytes received (container name is a tag) (`int64`)
	DockerResultContainerNetworkReceived = "network-bytes-received"
	// DockerResultContainerNetworkErrorReceived : Received errors (container name is a tag) (`int64`)
	DockerResultContainerNetworkErrorReceived = "network-errors-received"
	// DockerResultContainerNetworkDroppedReceived : Incoming packets dropped (container name is a tag) (`int64`)
	DockerResultContainerNetworkDroppedReceived = "network-dropped-received"
	// DockerResultContainerNetworkSent : Bytes sent (container name is a tag) (`int64`)
	DockerResultContainerNetworkSent = "network-bytes-sent"
	// DockerResultContainerNetworkErrorSent : Sent errors (container name is a tag) (`int64`)
	DockerResultContainerNetworkErrorSent = "network-errors-sent"
	// DockerResultContainerNetworkDroppedSent : Outgoing packets dropped (container name is a tag) (`int64`)
	DockerResultContainerNetworkDroppedSent = "network-dropped-sent"
	// DockerResultNetworkCount : the number of networks in the Docker daemon (`int64`)
	DockerResultNetworkCount = "network-count"
	// DockerResultVolumeCount : the number of volumes in the Docker daemon (`int64`)
	DockerResultVolumeCount = "volume-count"
	// DockerResultVolumeSize : the number of bytes used by all the volumes in the Docker daemon (`int64`)
	DockerResultVolumeSize = "volume-size"
	// DockerResultImageCount : the number of images in the Docker daemon (`int64`)
	DockerResultImageCount = "image-count"
	// DockerResultImageSize : the number of bytes used by all the images in the Docker daemon (`int64`)
	DockerResultImageSize = "image-size"

	// DockerTagContainerName : The name of a container, e.g. `"goofy_hodgkin"`
	DockerTagContainerName = "name"
	// DockerTagContainerInterface : The name of a container interface, e.g. `"eth0"`
	DockerTagContainerInterface = "interface"
)

const (
	// ElasticsearchURLClusterHealth : very simple status on the health of the cluster
	ElasticsearchURLClusterHealth = "cluster_health"
	// ElasticsearchURLClusterStats : statistics from a cluster wide perspective
	ElasticsearchURLClusterStats = "cluster_stats"
)

const (

	// ElasticsearchParamAddress : (mandatory) the address of the target elasticsearch server to gather metric from (string)
	ElasticsearchParamAddress = "address"
	// ElasticsearchParamTimeout (optional) : duration before the HTTP request times out (default value: 0)(`time.Duration`)
	ElasticsearchParamTimeout = "timeout"

	// ElasticsearchResultClusterName : ES cluster name (string)
	ElasticsearchResultClusterName = "cluster-name"
	// ElasticsearchResultStatus : Health level of the cluster (string)
	ElasticsearchResultStatus = "status"
	// ElasticsearchResultTimedOut : (boolean)
	ElasticsearchResultTimedOut = "timed-out"
	// ElasticsearchResultNumberOfNodes : Number of nodes in the cluster (float64)
	ElasticsearchResultNumberOfNodes = "number-of-nodes"
	// ElasticsearchResultNumberOfDataNodes : Number of data nodes in the cluster (float64)
	ElasticsearchResultNumberOfDataNodes = "number-of-data-nodes"
	// ElasticsearchResultActivePrimaryShards : Number of primary shards in the cluster (float64)
	ElasticsearchResultActivePrimaryShards = "active-primary-shards"
	// ElasticsearchResultActiveShards : Number of active shards in the cluster (float64)
	ElasticsearchResultActiveShards = "active-shards"
	// ElasticsearchResultRelocatingShards : Number of shards being relocated in the cluster (float64)
	ElasticsearchResultRelocatingShards = "relocating-shards"
	// ElasticsearchResultInitializingShards : Number of shards being initialized in the cluster (float64)
	ElasticsearchResultInitializingShards = "initializing-shards"
	// ElasticsearchResultUnassignedShards : Number of shards currently unassigned in the cluster (float64)
	ElasticsearchResultUnassignedShards = "unassigned-shards"
	// ElasticsearchResultDelayedUnassignedShards : Number of unassigned shards which allocation is delayed in the cluster (float64)
	ElasticsearchResultDelayedUnassignedShards = "delayed-unassigned-shards"
	// ElasticsearchResultNumberOfPendingTasks : Number of pending task in the cluster (float64)
	ElasticsearchResultNumberOfPendingTasks = "number-of-pending-tasks"
	// ElasticsearchResultNumberOfInFlightFetch : Number of in-flight fetch operations (float64)
	ElasticsearchResultNumberOfInFlightFetch = "number-of-in-flight-fetch"
	// ElasticsearchResultTaskMaxWaitingInQueueMillis : Maximum number of milliseconds a task is waiting in queue (float64)
	ElasticsearchResultTaskMaxWaitingInQueueMillis = "task-max-waiting-in-queue-millis"
	// ElasticsearchResultIndicesCount : Count of indices in the cluster (float64)
	ElasticsearchResultIndicesCount = "indices-count"
	// ElasticsearchResultDocsCount : Count of documents in the cluster (float64)
	ElasticsearchResultDocsCount = "docs-count"
	// ElasticsearchResultDocsDeleted : Count of deleted documents in the cluster (float64)
	ElasticsearchResultDocsDeleted = "docs-deleted"
	// ElasticsearchResultStoreSize : Size of the cluster storage (float64)
	ElasticsearchResultStoreSize = "store-size"
	// ElasticsearchResultQCMemory : Memory allocated to the cluster query cache(float64)
	ElasticsearchResultQCMemory = "querycache-memory"
	// ElasticsearchResultQCCountHit : Number of hits on the cluster query cache (float64)
	ElasticsearchResultQCCountHit = "querycache-count-hit"
	// ElasticsearchResultQCCountMiss : Number of miss on the cluster query cache (float64)
	ElasticsearchResultQCCountMiss = "querycache-count-miss"
	// ElasticsearchResultQCCountCache : Number of cache operations on the cluster query cache(float64)
	ElasticsearchResultQCCountCache = "querycache-count-cache"
	// ElasticsearchResultQCEvictions : Number of evictions from the cluster query cache (float64)
	ElasticsearchResultQCEvictions = "querycache-evictions"
	// ElasticsearchResultJVMHeapMax : JVM heap max size on the cluster (float64)
	ElasticsearchResultJVMHeapMax = "jvm-heap-max"
	// ElasticsearchResultJVMHeapUsed : JVM heap used size on the cluster (float64)
	ElasticsearchResultJVMHeapUsed = "jvm-heap-used"
	// ElasticsearchResultJVMThreads : Number of JVM threads on the cluster (float64)
	ElasticsearchResultJVMThreads = "jvm-threads"
)

const (
	// HTTPResponseContentNone : No content response
	HTTPResponseContentNone = "none"
	// HTTPResponseContentHeadersOnly : Only send HTTP headers from response
	HTTPResponseContentHeadersOnly = "headers-only"
	// HTTPResponseContentBodyOnly : Only send HTTP body from response
	HTTPResponseContentBodyOnly = "body-only"
	// HTTPResponseContentFull : Send complete HTTP response
	HTTPResponseContentFull = "full"
)

const (

	// HTTPParamMethod (optional, default `"GET"`) : HTTP request method (`"GET"`, `"POST"`, etc.)
	HTTPParamMethod = "method"
	// HTTPParamURL : HTTP request URL (`string`)
	HTTPParamURL = "url"
	// HTTPParamBody (optional) : HTTP Body of the request (`string`)
	HTTPParamBody = "body"
	// HTTPParamTimeout (optional) : duration before the HTTP request times out (`time.Duration`)
	HTTPParamTimeout = "timeout"
	// HTTPParamResponseContent : content from the response to be submitted in the results (`string`)
	HTTPParamResponseContent = "response-content"

	// HTTPResultRoundTripTime : time between sending the HTTP request and receiving the response, in nanoseconds
	// (`int64`)
	HTTPResultRoundTripTime = "rtt"
	// HTTPResultStatusCode : the HTTP response's status code (`int`)
	HTTPResultStatusCode = "status-code"
	// HTTPResultResponseContent : the HTTP response's content (depending on the probe's configuration) (`string`)
	HTTPResultResponseContent = "response-content"
)

const (

	// InfluxDBParamAddress : (mandatory) the address of the target influxdb server to gather metrics from (string)
	InfluxDBParamAddress = "address"

	// InfluxDBResultRuntimeAlloc : Alloc is bytes of allocated heap objects (uint64)
	InfluxDBResultRuntimeAlloc = "runtime-alloc"
	// InfluxDBResultRuntimeFrees : Frees is the cumulative count of heap objects freed (uint64)
	InfluxDBResultRuntimeFrees = "runtime-frees"
	// InfluxDBResultRuntimeHeapAlloc : HeapAlloc is bytes of allocated heap objects (uint64)
	InfluxDBResultRuntimeHeapAlloc = "runtime-heap-alloc"
	// InfluxDBResultRuntimeHeapIdle : HeapIdle is bytes in idle (unused) spans (uint64)
	InfluxDBResultRuntimeHeapIdle = "runtime-heap-idle"
	// InfluxDBResultRuntimeHeapInUse : HeapInuse is bytes in in-use spans (uint64)
	InfluxDBResultRuntimeHeapInUse = "runtime-heap-in-use"
	// InfluxDBResultRuntimeHeapObjects : HeapObjects is the number of allocated heap objects (uint64)
	InfluxDBResultRuntimeHeapObjects = "runtime-heap-objects"
	// InfluxDBResultRuntimeHeapReleased : HeapReleased is bytes of physical memory returned to the OS (uint64)
	InfluxDBResultRuntimeHeapReleased = "runtime-heap-released"
	// InfluxDBResultRuntimeHeapSys : HeapSys is bytes of heap memory obtained from the OS (uint64)
	InfluxDBResultRuntimeHeapSys = "runtime-heap-sys"
	// InfluxDBResultRuntimeLookups : Lookups is the number of pointer lookups performed by the runtime (uint64)
	InfluxDBResultRuntimeLookups = "runtime-lookups"
	// InfluxDBResultRuntimeMallocs : Mallocs is the cumulative count of heap objects allocated (uint64)
	InfluxDBResultRuntimeMallocs = "runtime-mallocs"
	// InfluxDBResultRuntimeNumGC : NumGC is the number of completed GC cycles (uint32)
	InfluxDBResultRuntimeNumGC = "runtime-num-gc"
	// InfluxDBResultRuntimeNumGoroutine : NumGoroutine returns the number of goroutines that currently exist (int)
	InfluxDBResultRuntimeNumGoroutine = "runtime-num-goroutine"
	// InfluxDBResultRuntimePauseTotalNs : PauseTotalNs is the cumulative nanoseconds in GC stop-the-world pauses since the program started (uint64)
	InfluxDBResultRuntimePauseTotalNs = "runtime-pause-total-ns"
	// InfluxDBResultRuntimeSys : Sys is the total bytes of memory obtained from the OS (uint64)
	InfluxDBResultRuntimeSys = "runtime-sys"
	// InfluxDBResultRuntimeTotalAlloc : TotalAlloc is cumulative bytes allocated for heap objects (uint64)
	InfluxDBResultRuntimeTotalAlloc = "runtime-total-alloc"

	// InfluxDBResultQueriesActive : queriesActive tracks the number of queries being handled at this instant in time (int)
	InfluxDBResultQueriesActive = "qe-queriesActive"
	// InfluxDBResultQueriesExecuted : Number of queries that have been executed (started) (int)
	InfluxDBResultQueriesExecuted = "qe-queriesExecuted"
	// InfluxDBResultQueriesFinished : Number of queries that have finished (int)
	InfluxDBResultQueriesFinished = "qe-queriesFinished"
	// InfluxDBResultQueryDurationNs : queryDurationNs tracks the cumulative wall time, in nanoseconds, of every query executed (int)
	InfluxDBResultQueryDurationNs = "qe-queryDurationNs"
	// InfluxDBResultQERecoveredPanics : Number of panics recovered by Query Executor (int)
	InfluxDBResultQERecoveredPanics = "qe-recoveredPanics"

	// InfluxDBResultPointReq : pointReq is incremented for every point that is attempted to be written, regardless of success (int)
	InfluxDBResultPointReq = "write-pointreq"
	// InfluxDBResultPointReqLocal : pointReqLocal is incremented for every point that is attempted to be written into a shard, regardless of success (int)
	InfluxDBResultPointReqLocal = "write-pointreqlocal"
	// InfluxDBResultWReq : req is incremented every time a batch of points is attempted to be written, regardless of success (int)
	InfluxDBResultWReq = "write-req"
	// InfluxDBResultSubWriteDrop : subWriteDrop is incremented every time a batch write to a subscriber is dropped due to contention or write saturation (int)
	InfluxDBResultSubWriteDrop = "write-subwritedrop"
	// InfluxDBResultSubWriteOk : subWriteOk is incremented every time a batch write to a subscriber succeeds (int)
	InfluxDBResultSubWriteOk = "write-subwriteok"
	// InfluxDBResultWriteDrop : writeDrop is incremented for every point dropped due to having a timestamp that does not match any existing retention policy (int)
	InfluxDBResultWriteDrop = "write-writedrop"
	// InfluxDBResultWriteError : writeError is incremented for every batch that was attempted to be written to a shard but failed (int)
	InfluxDBResultWriteError = "write-writeerror"
	// InfluxDBResultWriteOk : writeOk is incremented for every batch that was successfully written to a shard (int)
	InfluxDBResultWriteOk = "write-writeok"
	// InfluxDBResultWriteTimeout : writeTimeout is incremented every time a write failed due to timing out (int)
	InfluxDBResultWriteTimeout = "write-writetimeout"

	// InfluxDBResultCreateFailures :  (int)
	InfluxDBResultCreateFailures = "subscriber-createfailures"
	// InfluxDBResultPointsWritten : pointsWritten tracks the number of points successfully written to subscribers (int)
	InfluxDBResultPointsWritten = "subscriber-pointswritten"
	// InfluxDBResultWriteFailures : writeFailures tracks the number of batches that failed to send to subscribers (int)
	InfluxDBResultWriteFailures = "subscriber-writefailures"

	// InfluxDBResultQueryFail : queryFail  is incremented whenever a continuous query is executed but fails (int)
	InfluxDBResultQueryFail = "cq-queryfail"
	// InfluxDBResultQueryOk : queryOk is incremented whenever a continuous query is executed without a failure (int)
	InfluxDBResultQueryOk = "cq-queryok"

	// InfluxDBResultAuthFail : authFail indicates how many HTTP requests were aborted due to authentication being required but unsupplied or incorrect (int)
	InfluxDBResultAuthFail = "httpd-authfail"
	// InfluxDBResultClientError : clientError is incremented every time InfluxDB sends an HTTP response with a 4XX status code (int)
	InfluxDBResultClientError = "httpd-clienterror"
	// InfluxDBResultPingReq : pingReq is incremented every time InfluxDB serves the /ping HTTP endpoint (int)
	InfluxDBResultPingReq = "httpd-pingreq"
	// InfluxDBResultPointsWrittenDropped : Number of points dropped by the storage engine (int)
	InfluxDBResultPointsWrittenDropped = "httpd-pointswrittendropped"
	// InfluxDBResultPointsWrittenFail : pointsWrittenFail is incremented for every point (not every batch) that was accepted by the /write HTTP endpoint but was unable to be persisted (int)
	InfluxDBResultPointsWrittenFail = "httpd-pointswrittenfail"
	// InfluxDBResultPointsWrittenOK : pointsWrittenOK is incremented for every point (not every batch) that was accepted by the /write HTTP endpoint and persisted successfully (int)
	InfluxDBResultPointsWrittenOK = "httpd-pointswrittenok"
	// InfluxDBResultQueryReq : queryReq is incremented every time InfluxDB serves the /query HTTP endpoint (int)
	InfluxDBResultQueryReq = "httpd-queryreq"
	// InfluxDBResultQueryReqDurationNs : queryReqDurationNs tracks the cumulative wall time, in nanoseconds, of every query served (int)
	InfluxDBResultQueryReqDurationNs = "httpd-queryreqdurationns"
	// InfluxDBResultQueryRespBytes : queryRespBytes is increased for every byte InfluxDB sends in a successful query response (int)
	InfluxDBResultQueryRespBytes = "httpd-queryrespbytes"
	// InfluxDBResultRecoveredPanics : Number of panics recovered by HTTP handler (int)
	InfluxDBResultRecoveredPanics = "httpd-recoveredpanics"
	// InfluxDBResultReq : req is incremented for every HTTP request InfluxDB receives (int)
	InfluxDBResultReq = "httpd-req"
	// InfluxDBResultReqActive : reqActive is incremented when InfluxDB begins accepting an HTTP request and is decremented whenever InfluxDB finishes serving that request (int)
	InfluxDBResultReqActive = "httpd-reqactive"
	// InfluxDBResultReqDurationNs : reqDurationNs tracks the cumulative wall time, in nanoseconds, of every request served (int)
	InfluxDBResultReqDurationNs = "httpd-reqdurationns"
	// InfluxDBResultServerError : serverError is incremented every time InfluxDB sends an HTTP response with a 5XX status code (int)
	InfluxDBResultServerError = "httpd-servererror"
	// InfluxDBResultStatusReq : statusReq is incremented every time InfluxDB serves the /status HTTP endpoint (int)
	InfluxDBResultStatusReq = "httpd-statusreq"
	// InfluxDBResultWriteReq : writeReq is incremented every time InfluxDB serves the /write HTTP endpoint (int)
	InfluxDBResultWriteReq = "httpd-writereq"
	// InfluxDBResultWriteReqActive : writeReqActive tracks the number of write requests over HTTP being handled at this instant in time (int)
	InfluxDBResultWriteReqActive = "httpd-writereqactive"
	// InfluxDBResultWriteReqBytes : writeReqBytes tracks the total number of bytes of line protocol received by the /write endpoint (int)
	InfluxDBResultWriteReqBytes = "httpd-writereqbytes"
	// InfluxDBResultWriteReqDurationNs : writeReqDurationNs tracks the cumulative wall time, in nanoseconds, of every write request served (int)
	InfluxDBResultWriteReqDurationNs = "httpd-writereqdurationns"
)

const (

	// LoadResultLoad1 : System load (# of processes waiting for I/O or in the run queue) averaged over the last
	// minute (`float32`)
	LoadResultLoad1 = "load1"
	// LoadResultLoad5 : System load averaged over the last 5 minutes (`float32`)
	LoadResultLoad5 = "load5"
	// LoadResultLoad15 : System load averaged over the last 15 minutes (`float32`)
	LoadResultLoad15 = "load15"
	// LoadResultRunning : Number of processes currently running (`int`)
	LoadResultRunning = "proc-running"
	// LoadResultBlocked : Number of processes currently blocked, i.e. waiting for I/O (`int`)
	LoadResultBlocked = "proc-blocked"
)

const (

	// MemcachedParamAddress : Memcached server (`string`)
	MemcachedParamAddress = "address"

	// MemcachedResultUptime Number of seconds the Memcached server has been running since last restart. (uint64)
	MemcachedResultUptime = "uptime"
	// MemcachedResultCurrConnections Number of open connections to this Memcached server, should be the same value on all servers during normal operation. This is something like the count of mySQL's "SHOW PROCESSLIST" result rows. (uint64)
	MemcachedResultCurrConnections = "curr_connections"
	// MemcachedResultReservedFDs Number of misc fds used internally (uint64)
	MemcachedResultReservedFDs = "reserved_fds"
	// MemcachedResultCmdGet Number of "get" commands received since server startup not counting if they were successful or not. (uint64)
	MemcachedResultCmdGet = "cmd_get"
	// MemcachedResultCmdSet Number of "set" commands serviced since startup. (uint64)
	MemcachedResultCmdSet = "cmd_set"
	// MemcachedResultCmdFlush The "flush_all" command clears the whole cache and shouldn't be used during normal operation. (uint64)
	MemcachedResultCmdFlush = "cmd_flush"
	// MemcachedResultCmdTouch Cumulative number of touch reqs (uint64)
	MemcachedResultCmdTouch = "cmd_touch"
	// MemcachedResultGetHits Number of successful "get" commands (cache hits) since startup, divide them by the "cmd_get" value to get the cache hitrate. (uint64)
	MemcachedResultGetHits = "get_hits"
	// MemcachedResultGetMisses Number of failed "get" requests because nothing was cached for this key or the cached value was too old. (uint64)
	MemcachedResultGetMisses = "get_misses"
	// MemcachedResultGetExpired Number of items that have been requested but had already expired (uint64)
	MemcachedResultGetExpired = "get_expired"
	// MemcachedResultGetFlushed Number of items that have been requested but have been flushed via flush_all (uint64)
	MemcachedResultGetFlushed = "get_flushed"
	// MemcachedResultDeleteMisses Number of "delete" commands for keys not existing within the cache. These 107k failed deletes are deletions of non existent race keys (see above). (uint64)
	MemcachedResultDeleteMisses = "delete_misses"
	// MemcachedResultDeleteHits Stored keys may be deleted using the "delete" command, this system doesn't delete cached data itself, but it's using the Memcached to avoid recaching-races and the race keys are deleted once the race is over and fresh content has been cached. (uint64)
	MemcachedResultDeleteHits = "delete_hits"
	// MemcachedResultBytesRead Total number of bytes received from the network by this server. (uint64)
	MemcachedResultBytesRead = "bytes_read"
	// MemcachedResultBytesWritten Total number of bytes send to the network by this server. (uint64)
	MemcachedResultBytesWritten = "bytes_written"
	// MemcachedResultBytes Number of bytes currently used for caching items, this server currently uses ~6 MB of it's maximum allowed (limit_maxbytes) 1 GB cache size. (uint64)
	MemcachedResultBytes = "bytes"
	// MemcachedResultCurrItems Number of items currently in this server's cache. The production system of this development environment holds more than 8 million items. (uint64)
	MemcachedResultCurrItems = "curr_items"
	// MemcachedResultEvictions Number of objects removed from the cache to free up memory for new items because Memcached reached its maximum memory setting (limit_maxbytes). (uint64)
	MemcachedResultEvictions = "evictions"
)

const (

	// MemoryResultTotal : Total amount of RAM on this system, in bytes (`uint64`)
	MemoryResultTotal = "total"
	// MemoryResultAvailable : An estimate amount of RAM available to programs, in bytes (`uint64`)
	MemoryResultAvailable = "available"
	// MemoryResultUsed : Total amount of RAM used by programs, in bytes (`uint64`)
	MemoryResultUsed = "used"
	// MemoryResultUsedPercent : Percentage of RAM used by programs (`float32`)
	MemoryResultUsedPercent = "used-percent"
	// MemoryResultFree : Total amout of RAM not used by programs, in bytes (`uint64`)
	MemoryResultFree = "free"

	// MemoryResultSwapTotal : Total amount of swap memory on this system, in bytes (`uint64`)
	MemoryResultSwapTotal = "swap-total"
	// MemoryResultSwapFree : Total amout of swap memory not used by programs, in bytes (`uint64`)
	MemoryResultSwapFree = "swap-free"
	// MemoryResultSwapUsed : Total amount of swap memory used by programs, in bytes (`uint64`)
	MemoryResultSwapUsed = "swap-used"
	// MemoryResultSwapUsedPercent : Percentage of swap memory used by programs (`float32`)
	MemoryResultSwapUsedPercent = "swap-used-percent"
)

const (

	// MongoDBParamAddress : (mandatory) the address of the target mongodb server to gather metrics from (string)
	MongoDBParamAddress = "address"
	// MongoDBParamDatabases : (optional) the comma separated list of databases to gather metrics from (string)
	MongoDBParamDatabases = "databases"
	// MongoDBParamUsername : (optional) a username to authenticate to the MongoDB server (string)
	MongoDBParamUsername = "username"
	// MongoDBParamPassword : (optional) a password to authenticate to the MongoDB server (string)
	MongoDBParamPassword = "password"

	// MongoDBResultServerUptime : The number of seconds that the current MongoDB process has been active (int64)
	MongoDBResultServerUptime = "uptime"

	// MongoDBResultServerConnectionsCurrent : The number of incoming connections from clients to the database server (int32)
	MongoDBResultServerConnectionsCurrent = "connections_current"
	// MongoDBResultServerConnectionsAvailable : The number of unused incoming connections available (int32)
	MongoDBResultServerConnectionsAvailable = "connections_available"

	// MongoDBResultServerGlobalLockActiveClientsReaders : The number of the active client connections performing read operations (int32)
	MongoDBResultServerGlobalLockActiveClientsReaders = "gl_clients_readers"
	// MongoDBResultServerGlobalLockActiveClientWriters : The number of active client connections performing write operations (int32)
	MongoDBResultServerGlobalLockActiveClientWriters = "gl_clients_writers"

	// MongoDBResultServerNetworkIn : The number of bytes that reflects the amount of network traffic received by this database (int64)
	MongoDBResultServerNetworkIn = "network_in"
	// MongoDBResultServerNetworkOut : The number of bytes that reflects the amount of network traffic sent from this database (int64)
	MongoDBResultServerNetworkOut = "network_out"

	// MongoDBResultServerOpsInsert : The total number of insert operations received since the mongod instance last started (int64)
	MongoDBResultServerOpsInsert = "ops_insert"
	// MongoDBResultServerOpsQuery : The total number of queries operations received since the mongod instance last started (int64)
	MongoDBResultServerOpsQuery = "ops_query"
	// MongoDBResultServerOpsUpdate : The total number of update operations received since the mongod instance last started (int64)
	MongoDBResultServerOpsUpdate = "ops_update"
	// MongoDBResultServerOpsDelete : The total number of delete operations received since the mongod instance last started (int64)
	MongoDBResultServerOpsDelete = "ops_delete"
	// MongoDBResultServerOpsGetmore : The total number of getmore operations received since the mongod instance last started (int64)
	MongoDBResultServerOpsGetmore = "ops_getmore"
	// MongoDBResultServerOpsCommand : The total number of command operations received since the mongod instance last started (int64)
	MongoDBResultServerOpsCommand = "ops_command"

	// MongoDBResultServerMemResident : The value of mem.resident is roughly equivalent to the amount of RAM, in megabytes (MB), currently used by the database process (int32)
	MongoDBResultServerMemResident = "mem_resident"
	// MongoDBResultServerMemVirtual : mem.virtual displays the quantity, in megabytes (MB), of virtual memory used by the mongod process. (int32)
	MongoDBResultServerMemVirtual = "mem_virtual"
)

const (

	// MysqlParamAddress : Mysql server (host:port) (`string`)
	MysqlParamAddress = "address"
	// MysqlParamLogin : Mysql user account (`string`)
	MysqlParamLogin = "login"
	// MysqlParamPassword : Mysql user password (`string`)
	MysqlParamPassword = "password"

	// MysqlResultAbortedClients : The number of connections that were aborted because the client died without closing the connection properly.
	MysqlResultAbortedClients = "aborted-clients"
	// MysqlResultAbortedConnects :    The number of failed attempts to connect to the MySQL server.
	MysqlResultAbortedConnects = "aborted-connects"
	// MysqlResultBinlogCacheUse : The number of transactions that used the binary log cache.
	MysqlResultBinlogCacheUse = "binlog-cache-use"
	// MysqlResultBinlogStmtCacheUse : The number of nontransactional statements that used the binary log statement cache.
	MysqlResultBinlogStmtCacheUse = "binlog-stmt-cache-use"
	// MysqlResultBytesReceived : The number of bytes received from all clients.
	MysqlResultBytesReceived = "bytes-received"
	// MysqlResultBytesSent : The number of bytes sent to all clients.
	MysqlResultBytesSent = "bytes-sent"
	// MysqlResultComBegin : The number of times begin statement has been executed.
	MysqlResultComBegin = "com-begin"
	// MysqlResultComChangeDb : The number of times change-db statement has been executed.
	MysqlResultComChangeDb = "com-change-db"
	// MysqlResultComChangeMaster : The number of times change-master statement has been executed.
	MysqlResultComChangeMaster = "com-change-master"
	// MysqlResultComCommit : The number of times commit statement has been executed.
	MysqlResultComCommit = "com-commit"
	// MysqlResultComCreateDb : The number of times create-db statement has been executed.
	MysqlResultComCreateDb = "com-create-db"
	// MysqlResultComDelete : The number of times delete statement has been executed.
	MysqlResultComDelete = "com-delete"
	// MysqlResultComDeleteMulti : The number of times delete-multi statement has been executed.
	MysqlResultComDeleteMulti = "com-delete-multi"
	// MysqlResultComInsert : The number of times insert statement has been executed.
	MysqlResultComInsert = "com-insert"
	// MysqlResultComRollback : The number of times rollback statement has been executed.
	MysqlResultComRollback = "com-rollback"
	// MysqlResultComSelect : The number of times select statement has been executed.
	MysqlResultComSelect = "com-select"
	// MysqlResultComStmtExecute : The number of times stmt-execute statement has been executed.
	MysqlResultComStmtExecute = "com-stmt-execute"
	// MysqlResultComStmtFetch : The number of times stmt-fetch statement has been executed.
	MysqlResultComStmtFetch = "com-stmt-fetch"
	// MysqlResultComTruncate : The number of times truncate statement has been executed.
	MysqlResultComTruncate = "com-truncate"
	// MysqlResultComUpdate : The number of times update statement has been executed.
	MysqlResultComUpdate = "com-update"
	// MysqlResultConnectionErrorsAccept : The number of errors that occurred during calls to accept() on the listening port.
	MysqlResultConnectionErrorsAccept = "connection-errors-accept"
	// MysqlResultConnectionErrorsInternal : The number of connections refused due to internal errors in the server, such as failure to start a new thread or an out-of-memory condition.
	MysqlResultConnectionErrorsInternal = "connection-errors-internal"
	// MysqlResultConnectionErrorsMaxConnections : The number of connections refused because the server max-connections limit was reached.
	MysqlResultConnectionErrorsMaxConnections = "connection-errors-max-connections"
	// MysqlResultConnectionErrorsPeerAddress : The number of errors that occurred while searching for connecting client IP addresses.
	MysqlResultConnectionErrorsPeerAddress = "connection-errors-peer-address"
	// MysqlResultConnectionErrorsSelect : The number of errors that occurred during calls to select() or poll() on the listening port.
	MysqlResultConnectionErrorsSelect = "connection-errors-select"
	// MysqlResultConnectionErrorsTcpwrap : The number of connections refused by the libwrap library.
	MysqlResultConnectionErrorsTcpwrap = "connection-errors-tcpwrap"
	// MysqlResultConnections : The number of connection attempts (successful or not) to the MySQL server.
	MysqlResultConnections = "connections"
	// MysqlResultCreatedTmpDiskTables : The number of internal on-disk temporary tables created by the server while executing statements.
	MysqlResultCreatedTmpDiskTables = "created-tmp-disk-tables"
	// MysqlResultCreatedTmpTables : The number of internal temporary tables created by the server while executing statements.
	MysqlResultCreatedTmpTables = "created-tmp-tables"
	// MysqlResultFlushCommands : The number of times the server flushes tables, whether because a user executed a FLUSH TABLES statement or due to internal server operation.
	MysqlResultFlushCommands = "flush-commands"
	// MysqlResultHandlerReadFirst : The number of times the first entry in an index was read. If this value is high, it suggests that the server is doing a lot of full index scans.
	MysqlResultHandlerReadFirst = "handler-read-first"
	// MysqlResultHandlerReadKey : The number of requests to read a row based on a key. If this value is high, it is a good indication that your tables are properly indexed for your queries.
	MysqlResultHandlerReadKey = "handler-read-key"
	// MysqlResultHandlerReadLast : The number of requests to read the last key in an index.
	MysqlResultHandlerReadLast = "handler-read-last"
	// MysqlResultHandlerReadNext : The number of requests to read the next row in key order.
	MysqlResultHandlerReadNext = "handler-read-next"
	// MysqlResultHandlerReadPrev : The number of requests to read the previous row in key order.
	MysqlResultHandlerReadPrev = "handler-read-prev"
	// MysqlResultHandlerReadRnd : The number of requests to read a row based on a fixed position. This value is high if you are doing a lot of queries that require sorting of the result.
	MysqlResultHandlerReadRnd = "handler-read-rnd"
	// MysqlResultHandlerReadRndNext : The number of requests to read the next row in the data file. This value is high if you are doing a lot of table scans.
	MysqlResultHandlerReadRndNext = "handler-read-rnd-next"
	// MysqlResultInnodbBufferPoolPagesData : The number of pages in the InnoDB buffer pool containing data.
	MysqlResultInnodbBufferPoolPagesData = "innodb-buffer-pool-pages-data"
	// MysqlResultInnodbBufferPoolPagesDirty : The current number of dirty pages in the InnoDB buffer pool.
	MysqlResultInnodbBufferPoolPagesDirty = "innodb-buffer-pool-pages-dirty"
	// MysqlResultInnodbBufferPoolPagesFlushed : The number of requests to flush pages from the InnoDB buffer pool.
	MysqlResultInnodbBufferPoolPagesFlushed = "innodb-buffer-pool-pages-flushed"
	// MysqlResultInnodbBufferPoolPagesFree : The number of free pages in the InnoDB buffer pool.
	MysqlResultInnodbBufferPoolPagesFree = "innodb-buffer-pool-pages-free"
	// MysqlResultInnodbBufferPoolPagesMisc : The number of pages in the InnoDB buffer pool that are busy because they have been allocated for administrative overhead, such as row locks or the adaptive hash index.
	MysqlResultInnodbBufferPoolPagesMisc = "innodb-buffer-pool-pages-misc"
	// MysqlResultInnodbDataFsyncs : The number of fsync() operations so far.
	MysqlResultInnodbDataFsyncs = "innodb-data-fsyncs"
	// MysqlResultInnodbDataReads : The total number of data reads (OS file reads).
	MysqlResultInnodbDataReads = "innodb-data-reads"
	// MysqlResultInnodbDataWrites : The total number of data writes.
	MysqlResultInnodbDataWrites = "innodb-data-writes"
	// MysqlResultInnodbLogWaits : The number of times that the log buffer was too small and a wait was required for it to be flushed before continuing.
	MysqlResultInnodbLogWaits = "innodb-log-waits"
	// MysqlResultInnodbLogWrites : The number of physical writes to the InnoDB redo log file.
	MysqlResultInnodbLogWrites = "innodb-log-writes"
	// MysqlResultInnodbPageSize : InnoDB page size (default 16KB).
	MysqlResultInnodbPageSize = "innodb-page-size"
	// MysqlResultInnodbPagesRead : The number of pages read from the InnoDB buffer pool by operations on InnoDB tables.
	MysqlResultInnodbPagesRead = "innodb-pages-read"
	// MysqlResultInnodbPagesWritten : The number of pages written by operations on InnoDB tables.
	MysqlResultInnodbPagesWritten = "innodb-pages-written"
	// MysqlResultInnodbRowLockTimeMax : The maximum time to acquire a row lock for InnoDB tables, in milliseconds.
	MysqlResultInnodbRowLockTimeMax = "innodb-row-lock-time-max"
	// MysqlResultInnodbRowLockWaits : The number of times operations on InnoDB tables had to wait for a row lock.
	MysqlResultInnodbRowLockWaits = "innodb-row-lock-waits"
	// MysqlResultKeyBlocksUnused : The number of unused blocks in the MyISAM key cache.
	MysqlResultKeyBlocksUnused = "key-blocks-unused"
	// MysqlResultKeyBlocksUsed : The number of used blocks in the MyISAM key cache.
	MysqlResultKeyBlocksUsed = "key-blocks-used"
	// MysqlResultKeyReads : The number of physical reads of a key block from disk into the MyISAM key cache.
	MysqlResultKeyReads = "key-reads"
	// MysqlResultKeyWrites : The number of physical writes of a key block from the MyISAM key cache to disk.
	MysqlResultKeyWrites = "key-writes"
	// MysqlResultOpenFiles : The number of files that are open. This count includes regular files opened by the server.
	MysqlResultOpenFiles = "open-files"
	// MysqlResultOpenStreams : The number of streams that are open (used mainly for logging).
	MysqlResultOpenStreams = "open-streams"
	// MysqlResultOpenTables : The number of tables that are open.
	MysqlResultOpenTables = "open-tables"
	// MysqlResultPreparedStmtCount : The current number of prepared statements.
	MysqlResultPreparedStmtCount = "prepared-stmt-count"
	// MysqlResultQueries : The number of statements executed by the server.
	MysqlResultQueries = "queries"
	// MysqlResultSelectFullJoin : The number of joins that perform table scans because they do not use indexes.
	MysqlResultSelectFullJoin = "select-full-join"
	// MysqlResultSelectFullRangeJoin : The number of joins that used a range search on a reference table.
	MysqlResultSelectFullRangeJoin = "select-full-range-join"
	// MysqlResultSlowQueries : The number of queries that have taken more than long-query-time seconds.
	MysqlResultSlowQueries = "slow-queries"
	// MysqlResultUptime : The number of seconds that the server has been up.
	MysqlResultUptime = "uptime"
)

const (

	// NetworkParamInterfaces : A comma-separated list of interfaces to gather information about.
	// If the list is empty, return info about all interfaces. If the parameter is missing, return global information
	// for all interfaces.
	NetworkParamInterfaces = "interfaces"
	// NetworkParamInterval : (optional, default 1 second) interval over which network utilization is calculated
	NetworkParamInterval = "interval"

	// NetworkResultBytesSent : Number of bytes sent through the interface (uint64)
	NetworkResultBytesSent = "bytes-sent"
	// NetworkResultBytesRecv : Number of bytes received through the interface (uint64)
	NetworkResultBytesRecv = "bytes-received"
	// NetworkResultPacketsSent : Number of network packets sent through the interface (uint64)
	NetworkResultPacketsSent = "packets-sent"
	// NetworkResultPacketsRecv : Number of network packets receives through the interface (uint64)
	NetworkResultPacketsRecv = "packets-received"
	// NetworkResultErrIn : Number of errors while receiving through the interface (uint64)
	NetworkResultErrIn = "error-in"
	// NetworkResultErrOut : Number of errors while sending through the interface (uint64)
	NetworkResultErrOut = "error-out"
	// NetworkResultTCPConn : Number of open TCP connections on this interface (uint64)
	NetworkResultTCPConn = "tcp-connections"
	// NetworkResultUDPConn : Number of open UDP connections on this interface (uint64)
	NetworkResultUDPConn = "udp-connections"

	// NetworkTagInterface : The network interface, e.g. `"eth0"`
	NetworkTagInterface = "interface"
)

const (

	// NginxParamURL : Nginx request URL (`string`)
	NginxParamURL = "url"
	// NginxParamTimeout (optional) : duration before the Nginx request times out (`time.Duration`)
	NginxParamTimeout = "timeout"

	// NginxResultActiveConnections : the number of active client connections including waiting connections. (`int`)
	NginxResultActiveConnections = "active-connections"
	// NginxResultAccepts : the total number of accepted connections (`int`)
	NginxResultAccepts = "accept-connections"
	// NginxResultHandled : the total number of handled connections. (`int`)
	NginxResultHandled = "handled-connections"
	// NginxResultRequests : the total number of client requests. (`int`)
	NginxResultRequests = "requests"
	// NginxResultReading : the current number of connections where nginx is reading the request header (`int`)
	NginxResultReading = "reading"
	// NginxResultWriting : the current number of connections where nginx is writing the response back to the client (`int`)
	NginxResultWriting = "writing"
	// NginxResultWaiting : the current number of idle client connections waiting for a request (`int`)
	NginxResultWaiting = "waiting"
)

const (

	// NTPParamAddress : NTP server (`string`)
	NTPParamAddress = "address"

	// NTPResultClockOffset : the estimated offset of the local system clock relative to the server's clock in nanosecond (`int64`)
	NTPResultClockOffset = "clock-offset"
	// NTPResutRTT : an estimate of the round-trip-time delay between the client and the server in nanosecond (`int64`)
	NTPResutRTT = "rtt"
)

const (

	// PHPFPMParamAddress : PHPFPM server (`string`)
	PHPFPMParamAddress = "address"
	// PHPFPMParamURL : PHPFPM status endpoint URL (`string`)
	PHPFPMParamURL = "url"

	// PHPFPMResultListenQueue the number of request in the queue of pending connections. (uint)
	PHPFPMResultListenQueue = "listen_queue"
	// PHPFPMResultIdleProcesses the number of idle processes. (uint)
	PHPFPMResultIdleProcesses = "idle_processes"
	// PHPFPMResultActiveProcesses the number of active processes. (uint)
	PHPFPMResultActiveProcesses = "active_processes"
	// PHPFPMResultSlowRequests Enable php-fpm slow-log before you consider this. If this value is non-zero you may have slow php processes. (uint)
	PHPFPMResultSlowRequests = "slow_requests"
)

const (

	// PingParamAddress : (mandatory) target address, IP or hostname (`string`)
	PingParamAddress = "address"
	// PingParamInterval : (optional) the wait time between each packet send, default 1s (`time.Duration`)
	PingParamInterval = "interval"
	// PingParamCount : (optional) the number of ICMP packets to send, default 4 (`int`)
	PingParamCount = "count"
	// PingParamTimeout : (optional) the time to run the ping, until it exits. If the timeout is reached before the
	// packet count has been reached, exits anyway. Defaults to 10s (`time.Duration`)
	PingParamTimeout = "timeout"

	// PingResultSent : the number of packets sent (`int`)
	PingResultSent = "sent"
	// PingResultRecv : the number of packets received (`int`)
	PingResultRecv = "received"
	// PingResultMin : the minimum round trip time, in nanoseconds (`int64`)
	PingResultMin = "min"
	// PingResultMax : the maximum round trip time, in nanoseconds (`int64`)
	PingResultMax = "max"
	// PingResultAvg : the average round trip time, in nanoseconds (`int64`)
	PingResultAvg = "avg"
	// PingResultStdDev : the standard deviation of round trip times, in nanoseconds (`int64`)
	PingResultStdDev = "stddev"

	// PingTagAddress : the address of the target that was pinged
	PingTagAddress = "address"
)

const (

	// PostgresqlParamAddress : Postgresql server (host:port) (`string`)
	PostgresqlParamAddress = "address"
	// PostgresqlParamUsername : Postgresql user account (`string`)
	PostgresqlParamUsername = "username"
	// PostgresqlParamPassword : Postgresql user password (`string`)
	PostgresqlParamPassword = "password"
	// PostgresqlParamSSLMode : Postgresql connection SSL Mode (`string`)
	PostgresqlParamSSLMode = "sslmode"

	// PostgresqlResultCurrentConnections : Number of backends currently connected to this database
	PostgresqlResultCurrentConnections = "current_connections"
	// PostgresqlResultMaxConnections : The maximum number of client connections allowed.
	PostgresqlResultMaxConnections = "max_connections"

	// PostgresqlResultSharedBufferHits : Number of times disk blocks were found already in the buffer cache, so that a read was not necessary
	PostgresqlResultSharedBufferHits = "shared_buffer_hits"
	// PostgresqlResultSharedBufferReads : Number of disk blocks read
	PostgresqlResultSharedBufferReads = "shared_buffer_reads"

	// PostgresqlResultTempFilesCount : Number of temporary files created by queries
	PostgresqlResultTempFilesCount = "temp_files_count"
	// PostgresqlResultTempFilesBytes : Total amount of data written to temporary files by queries
	PostgresqlResultTempFilesBytes = "temp_file_bytes"

	// PostgresqlResultRowsReturned : Number of rows returned by queries
	PostgresqlResultRowsReturned = "rows_returned"
	// PostgresqlResultRowsFetched : Number of rows fetched by queries
	PostgresqlResultRowsFetched = "rows_fetched"
	// PostgresqlResultRowsInserted : Number of rows inserted by queries
	PostgresqlResultRowsInserted = "rows_inserted"
	// PostgresqlResultRowsUpdated : Number of rows updated by queries
	PostgresqlResultRowsUpdated = "rows_updated"
	// PostgresqlResultRowsDeleted : Number of rows deleted by queries
	PostgresqlResultRowsDeleted = "rows_deleted"

	// PostgresqlResultDeadlocks : Number of deadlocks detected
	PostgresqlResultDeadlocks = "deadlocks"

	// PostgresqlResultIndexSize : Total size of index on disk
	PostgresqlResultIndexSize = "index_size"
	// PostgresqlResultTableSize : Total size of table on disk
	PostgresqlResultTableSize = "table_size"
	// PostgresqlResultToastSize : Total size of toast on disk
	PostgresqlResultToastSize = "toast_size"

	// PostgresqlResultRowsDead : Estimated number of dead rows
	PostgresqlResultRowsDead = "n_dead_tup"
	// PostgresqlResultRowsLive : Estimated number of live rows
	PostgresqlResultRowsLive = "n_live_tup"

	// PostgresqlResultCheckpointsRequested : Number of requested checkpoints that have been performed
	PostgresqlResultCheckpointsRequested = "checkpoints_requested"
	// PostgresqlResultCheckpointsScheduled : Number of scheduled checkpoints that have been performed
	PostgresqlResultCheckpointsScheduled = "checkpoints_scheduled"

	// PostgresqlResultBuffersBackend : Number of buffers written directly by a backend
	PostgresqlResultBuffersBackend = "buffers_backend"
	// PostgresqlResultBuffersBackground : Number of buffers written by the background writer
	PostgresqlResultBuffersBackground = "buffers_background"
	// PostgresqlResultBuffersCheckpoint : Number of buffers written during checkpoints
	PostgresqlResultBuffersCheckpoint = "buffers_checkpoint"
)

const (

	// ProcessParamNames : (mandatory) The names of the processes to gather info for. A process "name" is usually
	// the name of the executable that was launched.
	ProcessParamNames = "names"

	// ProcessResultCommandLine : The full command-line used to launch this process (string)
	ProcessResultCommandLine = "command-line"
	// ProcessResultPID : The PID of this process (int32)
	ProcessResultPID = "pid"
	// ProcessResultCreateTime : The exact time this process started (int64)
	ProcessResultCreateTime = "create-time"
	// ProcessResultStatus : A character representing the current status of the process. R: Running, S: Sleep, T: Stop,
	// I: Idle, Z: Zombie, W: Wait, L: Lock. (string)
	ProcessResultStatus = "status"
	// ProcessResultCPU : An approximate percentage of CPU power used by this process (float64)
	ProcessResultCPU = "cpu"
	// ProcessResultMemory : An approximate percentage of RAM used by this process (float64)
	ProcessResultMemory = "memory"
	// ProcessResultRSS : The "Resident Set Size" is the amount of RAM used by this process, in bytes (uint64)
	ProcessResultRSS = "rss"
	// ProcessResultVMS : The "Virtual Memory Size" is the total size of memory addressable by this process, in bytes
	// (uint64)
	ProcessResultVMS = "vms"
	// ProcessResultThreads : The number of threads this process is currently running (uint64)
	ProcessResultThreads = "threads"
	// ProcessResultOpenFiles : The number of files currently opened by this process (uint64)
	ProcessResultOpenFiles = "files"
	// ProcessResultConnections : The number of network connections open by this process (uint64)
	ProcessResultConnections = "connections"

	// ProcessTagName : The name of this process (string)
	ProcessTagName = "name"
)

const (

	// RedisParamAddress : (mandatory) the address of the target redis server to gather metric from (string)
	RedisParamAddress = "address"

	// RedisResultConnectedClients : The number of clients currently connected to this Redis server (uint64)
	RedisResultConnectedClients = "connected-clients"
	// RedisResultBlockedClients : The number of clients pending on a blocking call (uint64)
	RedisResultBlockedClients = "blocked-clients"
	// RedisResultUsedMemory : The amout of memory allocated by this Redis server, in bytes (uint64)
	RedisResultUsedMemory = "used-memory"
	// RedisResultMemoryFragmentationRatio : The ratio between the memory allocated by Redis and the memory as seen by
	// the operating system. See Redis INFO documentation for details. (float32)
	RedisResultMemoryFragmentationRatio = "mem-frag-ratio"
	// RedisResultCacheHitRatio : The cache hit ratio is the ratio between the # cache hits and the # of key requests.
	// (float32)
	RedisResultCacheHitRatio = "cache-hit-ratio"
	// RedisResultUptime : The time since the Redis server was launched, in seconds (uint64)
	RedisResultUptime = "uptime"
	// RedisResultChangesSinceLastSave : The number of changes since the last time the database was saved to disk. The
	// number of changes that would be lost upon restart. (uint64)
	RedisResultChangesSinceLastSave = "changes-since-last-save"
	// RedisResultLastSaveTime : The UNIX timestamp of the last time the database was saved to disk. (uint64)
	RedisResultLastSaveTime = "last-save-time"
	// RedisResultOpsPerSec : The number of commands processed by the Redis server per second. (uint64)
	RedisResultOpsPerSec = "ops-per-sec"
	// RedisResultRejectedConnections : The number of connections rejected because of the maximum connections limit. (uint64)
	RedisResultRejectedConnections = "rejected-connections"
	// RedisResultInputKbps : The incoming bandwith usage of the Redis server, in kilobytes per second. (uint64)
	RedisResultInputKbps = "input-kbps"
	// RedisResultOutputKbps : The outgoing bandwith usage of the Redis server, in kilobytes per second. (uint64)
	RedisResultOutputKbps = "output-kbps"
	// RedisResultExpiredKeys : Number of keys that have been removed when reaching their expiration date.(uint64)
	RedisResultExpiredKeys = "expired-keys"
	// RedisResultEvictedKeys : Number of keys removed (evicted) due to reaching maximum memory.(uint64)
	RedisResultEvictedKeys = "evicted-keys"
	// RedisResultMasterLastIO : Time in seconds since the last interaction with the master Redis server (uint64)
	RedisResultMasterLastIO = "master-last-io"
	// RedisResultMasterLinkStatus : The current status of the link to the master Redis server (string)
	RedisResultMasterLinkStatus = "master-link-status"
	// RedisResultMasterLinkDownSince : The time in seconds since the link between master and slave is down (uint64)
	RedisResultMasterLinkDownSince = "master-link-down-since"
	// RedisResultConnectedSlaves : The number of slave instances connected to the master Redis server (uint64)
	RedisResultConnectedSlaves = "connected-slaves"
)

const (

	// SNMPParamAddress : (mandatory) the address of the target SNMP server to get metric from (string)
	SNMPParamAddress = "address"
	// SNMPParamPort : (optional, default: 161) the port of the target SNMP server to get metric from (float64)
	SNMPParamPort = "port"
	// SNMPParamCommunity : (optional, default: public) the community of the target SNMP server to get metric from (string)
	SNMPParamCommunity = "community"
	// SNMPParamTimeout (optional, default: 10s) : duration before the SNMP request times out (time.Duration)
	SNMPParamTimeout = "timeout"
	// SNMPParamOID (mandatory) : A comma-separated list of OIDs to get (string)
	SNMPParamOID = "oid"

	// SNMPResultValue : Value for the SNMP OID (interface)
	SNMPResultValue = "value"

	// SNMPTagOID : The requested OID, e.g. `"1.3.6.1.2.1.1.4.0"`
	SNMPTagOID = "oid"
)

const (

	// SybaseParamAddress : Sybase server (host:port) (`string`)
	SybaseParamAddress = "address"
	// SybaseParamLogin : Sybase user account (`string`)
	SybaseParamLogin = "login"
	// SybaseParamPassword : Sybase user password (`string`)
	SybaseParamPassword = "password"
	// SybaseParamBlockedProcess : Number of seconds before a process is blocked (`int`) default 30
	SybaseParamBlockedProcess = "blocked-process"
	// SybaseParamLongTransactions : Number of seconds before a transaction is considered long (`int`) default 30
	SybaseParamLongTransactions = "long-transaction"

	// SybaseResultVersion : The version of the server.
	SybaseResultVersion = "version"
	// SybaseResultDatabasesCount : The number of databases on the server.
	SybaseResultDatabasesCount = "db-count"
	// SybaseResultProcessesCount : The number of processes on the server.
	SybaseResultProcessesCount = "proc-count"
	// SybaseResultBlockedProcesses : The number of processes blocked for more than SybaseParamBlockedProcess seconds.
	SybaseResultBlockedProcesses = "blocked-proc-count"
	// SybaseResultLongTransactions : The number of transactions lasting more than SybaseParamLongTransaction seconds.
	SybaseResultLongTransactions = "long-transaction"
	// SybaseResultDBSegmap : The number of segmap associated with a database.
	SybaseResultDBSegmap = "segmap"
	// SybaseResultDBAllocated : The number of allocated MB associated with a database.
	SybaseResultDBAllocated = "allocated"
	// SybaseResultDBFree : The number of free MB associated with a database.
	SybaseResultDBFree = "free"

	// SybaseTagDBname : The name of the database of the metric, e.g. "master"
	SybaseTagDBname = "dbname"
)

const (

	// TLSParamHost : TLS request URL (`string`)
	TLSParamHost = "host"

	// TLSExpiresIn : time before the TLS certificate expires, in nanoseconds (`int64`)
	TLSExpiresIn = "expires-in"
	// TLSChainExpiresIn : time before any TLS certificate in the chain expires, in nanoseconds (`int64`)
	TLSChainExpiresIn = "chain-expires-in"
	// TLSHash : the TLS certificate's hash (`string`)
	TLSHash = "hash"
	// TLSSignatureList : list of the TLS certificate's signature algorithm in the full chain (`string`)
	TLSSignatureList = "signature-list"
)

const (

	// UptimeResultUptime : System uptime (number of seconds since last boot) (`uint64`)
	UptimeResultUptime = "uptime"
	// UptimeResultBoottime : System last boot time (expressed in seconds since epoch) (`uint64`)
	UptimeResultBoottime = "boottime"
)