mongodb

package
v1.0.0-...-47f3d97 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 30, 2019 License: MIT Imports: 17 Imported by: 0

README

MongoDB Input Plugin

Configuration:
[[inputs.mongodb]]
  ## An array of URLs of the form:
  ##   "mongodb://" [user ":" pass "@"] host [ ":" port]
  ## For example:
  ##   mongodb://user:auth_key@10.10.3.30:27017,
  ##   mongodb://10.10.3.33:18832,
  servers = ["mongodb://127.0.0.1:27017"]

  ## When true, collect per database stats
  # gather_perdb_stats = false

  ## Optional TLS Config
  # tls_ca = "/etc/telegraf/ca.pem"
  # tls_cert = "/etc/telegraf/cert.pem"
  # tls_key = "/etc/telegraf/key.pem"
  ## Use TLS but skip chain & host verification
  # insecure_skip_verify = false
Permissions:

If your MongoDB instance has access control enabled you will need to connect as a user with sufficient rights.

With MongoDB 3.4 and higher, the clusterMonitor role can be used. In version 3.2 you may also need these additional permissions:

> db.grantRolesToUser("user", [{role: "read", actions: "find", db: "local"}])

If the user is missing required privileges you may see an error in the Telegraf logs similar to:

Error in input [mongodb]: not authorized on admin to execute command { serverStatus: 1, recordStats: 0 }
Metrics:
  • mongodb
    • tags:
      • hostname
    • fields:
      • active_reads (integer)
      • active_writes (integer)
      • commands (integer)
      • connections_current (integer)
      • connections_available (integer)
      • connections_total_created (integer)
      • cursor_timed_out_count (integer)
      • cursor_no_timeout_count (integer)
      • cursor_pinned_count (integer)
      • cursor_total_count (integer)
      • deletes (integer)
      • document_deleted (integer)
      • document_inserted (integer)
      • document_returned (integer)
      • document_updated (integer)
      • flushes (integer)
      • flushes_total_time_ns (integer)
      • getmores (integer)
      • inserts (integer
      • jumbo_chunks (integer)
      • member_status (string)
      • net_in_bytes_count (integer)
      • net_out_bytes_count (integer)
      • open_connections (integer)
      • percent_cache_dirty (float)
      • percent_cache_used (float)
      • queries (integer)
      • queued_reads (integer)
      • queued_writes (integer)
      • repl_commands (integer)
      • repl_deletes (integer)
      • repl_getmores (integer)
      • repl_inserts (integer)
      • repl_lag (integer)
      • repl_queries (integer)
      • repl_updates (integer)
      • repl_oplog_window_sec (integer)
      • resident_megabytes (integer)
      • state (string)
      • total_available (integer)
      • total_created (integer)
      • total_in_use (integer)
      • total_refreshing (integer)
      • ttl_deletes (integer)
      • ttl_passes (integer)
      • updates (integer)
      • vsize_megabytes (integer)
      • wtcache_app_threads_page_read_count (integer)
      • wtcache_app_threads_page_read_time (integer)
      • wtcache_app_threads_page_write_count (integer)
      • wtcache_bytes_read_into (integer)
      • wtcache_bytes_written_from (integer)
      • wtcache_pages_read_into (integer)
      • wtcache_pages_requested_from (integer)
      • wtcache_current_bytes (integer)
      • wtcache_max_bytes_configured (integer)
      • wtcache_internal_pages_evicted (integer)
      • wtcache_modified_pages_evicted (integer)
      • wtcache_unmodified_pages_evicted (integer)
      • wtcache_pages_evicted_by_app_thread (integer)
      • wtcache_pages_queued_for_eviction (integer)
      • wtcache_server_evicting_pages (integer)
      • wtcache_tracked_dirty_bytes (integer)
      • wtcache_worker_thread_evictingpages (integer)
      • commands_per_sec (integer, deprecated in 1.10; use commands))
      • cursor_no_timeout (integer, opened/sec, deprecated in 1.10; use cursor_no_timeout_count))
      • cursor_pinned (integer, opened/sec, deprecated in 1.10; use cursor_pinned_count))
      • cursor_timed_out (integer, opened/sec, deprecated in 1.10; use cursor_timed_out_count))
      • cursor_total (integer, opened/sec, deprecated in 1.10; use cursor_total_count))
      • deletes_per_sec (integer, deprecated in 1.10; use deletes))
      • flushes_per_sec (integer, deprecated in 1.10; use flushes))
      • getmores_per_sec (integer, deprecated in 1.10; use getmores))
      • inserts_per_sec (integer, deprecated in 1.10; use inserts))
      • net_in_bytes (integer, bytes/sec, deprecated in 1.10; use net_out_bytes_count))
      • net_out_bytes (integer, bytes/sec, deprecated in 1.10; use net_out_bytes_count))
      • queries_per_sec (integer, deprecated in 1.10; use queries))
      • repl_commands_per_sec (integer, deprecated in 1.10; use repl_commands))
      • repl_deletes_per_sec (integer, deprecated in 1.10; use repl_deletes)
      • repl_getmores_per_sec (integer, deprecated in 1.10; use repl_getmores)
      • repl_inserts_per_sec (integer, deprecated in 1.10; use repl_inserts))
      • repl_queries_per_sec (integer, deprecated in 1.10; use repl_queries))
      • repl_updates_per_sec (integer, deprecated in 1.10; use repl_updates))
      • ttl_deletes_per_sec (integer, deprecated in 1.10; use ttl_deltes))
      • ttl_passes_per_sec (integer, deprecated in 1.10; use ttl_passes))
      • updates_per_sec (integer, deprecated in 1.10; use updates))
  • mongodb_db_stats
    • tags:
      • db_name
      • hostname
    • fields:
      • avg_obj_size (float)
      • collections (integer)
      • data_size (integer)
      • index_size (integer)
      • indexes (integer)
      • num_extents (integer)
      • objects (integer)
      • ok (integer)
      • storage_size (integer)
      • type (string)
  • mongodb_shard_stats
    • tags:
      • hostname
    • fields:
      • in_use (integer)
      • available (integer)
      • created (integer)
      • refreshing (integer)
Example Output:
mongodb,hostname=127.0.0.1:27017 active_reads=0i,active_writes=0i,commands=1335i,commands_per_sec=7i,connections_available=814i,connections_current=5i,connections_total_created=0i,cursor_no_timeout=0i,cursor_no_timeout_count=0i,cursor_pinned=0i,cursor_pinned_count=1i,cursor_timed_out=0i,cursor_timed_out_count=0i,cursor_total=0i,cursor_total_count=1i,deletes=0i,deletes_per_sec=0i,document_deleted=0i,document_inserted=0i,document_returned=13i,document_updated=0i,flushes=5i,flushes_per_sec=0i,getmores=269i,getmores_per_sec=0i,inserts=0i,inserts_per_sec=0i,jumbo_chunks=0i,member_status="PRI",net_in_bytes=986i,net_in_bytes_count=358006i,net_out_bytes=23906i,net_out_bytes_count=661507i,open_connections=5i,percent_cache_dirty=0,percent_cache_used=0,queries=18i,queries_per_sec=3i,queued_reads=0i,queued_writes=0i,repl_commands=0i,repl_commands_per_sec=0i,repl_deletes=0i,repl_deletes_per_sec=0i,repl_getmores=0i,repl_getmores_per_sec=0i,repl_inserts=0i,repl_inserts_per_sec=0i,repl_lag=0i,repl_oplog_window_sec=24355215i,repl_queries=0i,repl_queries_per_sec=0i,repl_updates=0i,repl_updates_per_sec=0i,resident_megabytes=62i,state="PRIMARY",total_available=0i,total_created=0i,total_in_use=0i,total_refreshing=0i,ttl_deletes=0i,ttl_deletes_per_sec=0i,ttl_passes=23i,ttl_passes_per_sec=0i,updates=0i,updates_per_sec=0i,vsize_megabytes=713i,wtcache_app_threads_page_read_count=13i,wtcache_app_threads_page_read_time=74i,wtcache_app_threads_page_write_count=0i,wtcache_bytes_read_into=55271i,wtcache_bytes_written_from=125402i,wtcache_current_bytes=117050i,wtcache_max_bytes_configured=1073741824i,wtcache_pages_evicted_by_app_thread=0i,wtcache_pages_queued_for_eviction=0i,wtcache_server_evicting_pages=0i,wtcache_tracked_dirty_bytes=0i,wtcache_worker_thread_evictingpages=0i 1547159491000000000
mongodb_db_stats,db_name=admin,hostname=127.0.0.1:27017 avg_obj_size=241,collections=2i,data_size=723i,index_size=49152i,indexes=3i,num_extents=0i,objects=3i,ok=1i,storage_size=53248i,type="db_stat" 1547159491000000000
mongodb_db_stats,db_name=local,hostname=127.0.0.1:27017 avg_obj_size=813.9705882352941,collections=6i,data_size=55350i,index_size=102400i,indexes=5i,num_extents=0i,objects=68i,ok=1i,storage_size=204800i,type="db_stat" 1547159491000000000
mongodb_shard_stats,hostname=127.0.0.1:27017,in_use=3i,available=3i,created=4i,refreshing=0i 1522799074000000000

Documentation

Index

Constants

View Source 
const (
	Always   = 1 << iota // always activate the column
	Discover             // only active when mongostat is in discover mode
	Repl                 // only active if one of the nodes being monitored is in a replset
	Locks                // only active if node is capable of calculating lock info
	AllOnly              // only active if mongostat was run with --all option
	MMAPOnly             // only active if node has mmap-specific fields
	WTOnly               // only active if node has wiredtiger-specific fields
)

Flags to determine cases when to activate/deactivate columns for output.

View Source 
const (
	MongosProcess = "mongos"
)

Variables

View Source 
var DbDataStats = map[string]string{
	"collections":  "Collections",
	"objects":      "Objects",
	"avg_obj_size": "AvgObjSize",
	"data_size":    "DataSize",
	"storage_size": "StorageSize",
	"num_extents":  "NumExtents",
	"indexes":      "Indexes",
	"index_size":   "IndexSize",
	"ok":           "Ok",
}
View Source 
var DefaultClusterStats = map[string]string{
	"jumbo_chunks": "JumboChunksCount",
}
View Source 
var DefaultReplStats = map[string]string{
	"repl_inserts":          "InsertRCnt",
	"repl_inserts_per_sec":  "InsertR",
	"repl_queries":          "QueryRCnt",
	"repl_queries_per_sec":  "QueryR",
	"repl_updates":          "UpdateRCnt",
	"repl_updates_per_sec":  "UpdateR",
	"repl_deletes":          "DeleteRCnt",
	"repl_deletes_per_sec":  "DeleteR",
	"repl_getmores":         "GetMoreRCnt",
	"repl_getmores_per_sec": "GetMoreR",
	"repl_commands":         "CommandRCnt",
	"repl_commands_per_sec": "CommandR",
	"member_status":         "NodeType",
	"state":                 "NodeState",
	"repl_lag":              "ReplLag",
	"repl_oplog_window_sec": "OplogTimeDiff",
}
View Source 
var DefaultShardStats = map[string]string{
	"total_in_use":     "TotalInUse",
	"total_available":  "TotalAvailable",
	"total_created":    "TotalCreated",
	"total_refreshing": "TotalRefreshing",
}
View Source 
var DefaultStats = map[string]string{
	"inserts":                   "InsertCnt",
	"inserts_per_sec":           "Insert",
	"queries":                   "QueryCnt",
	"queries_per_sec":           "Query",
	"updates":                   "UpdateCnt",
	"updates_per_sec":           "Update",
	"deletes":                   "DeleteCnt",
	"deletes_per_sec":           "Delete",
	"getmores":                  "GetMoreCnt",
	"getmores_per_sec":          "GetMore",
	"commands":                  "CommandCnt",
	"commands_per_sec":          "Command",
	"flushes":                   "FlushesCnt",
	"flushes_per_sec":           "Flushes",
	"flushes_total_time_ns":     "FlushesTotalTime",
	"vsize_megabytes":           "Virtual",
	"resident_megabytes":        "Resident",
	"queued_reads":              "QueuedReaders",
	"queued_writes":             "QueuedWriters",
	"active_reads":              "ActiveReaders",
	"active_writes":             "ActiveWriters",
	"net_in_bytes_count":        "NetInCnt",
	"net_in_bytes":              "NetIn",
	"net_out_bytes_count":       "NetOutCnt",
	"net_out_bytes":             "NetOut",
	"open_connections":          "NumConnections",
	"ttl_deletes":               "DeletedDocumentsCnt",
	"ttl_deletes_per_sec":       "DeletedDocuments",
	"ttl_passes":                "PassesCnt",
	"ttl_passes_per_sec":        "Passes",
	"cursor_timed_out":          "TimedOutC",
	"cursor_timed_out_count":    "TimedOutCCnt",
	"cursor_no_timeout":         "NoTimeoutC",
	"cursor_no_timeout_count":   "NoTimeoutCCnt",
	"cursor_pinned":             "PinnedC",
	"cursor_pinned_count":       "PinnedCCnt",
	"cursor_total":              "TotalC",
	"cursor_total_count":        "TotalCCnt",
	"document_deleted":          "DeletedD",
	"document_inserted":         "InsertedD",
	"document_returned":         "ReturnedD",
	"document_updated":          "UpdatedD",
	"connections_current":       "CurrentC",
	"connections_available":     "AvailableC",
	"connections_total_created": "TotalCreatedC",
}
View Source 
var MmapStats = map[string]string{
	"mapped_megabytes":     "Mapped",
	"non-mapped_megabytes": "NonMapped",
	"page_faults":          "FaultsCnt",
	"page_faults_per_sec":  "Faults",
}
View Source 
var ShardHostStats = map[string]string{
	"in_use":     "InUse",
	"available":  "Available",
	"created":    "Created",
	"refreshing": "Refreshing",
}
View Source 
var StatHeaders = []StatHeader{
	{"", Always},
	{"insert", Always},
	{"query", Always},
	{"update", Always},
	{"delete", Always},
	{"getmore", Always},
	{"command", Always},
	{"% dirty", WTOnly},
	{"% used", WTOnly},
	{"flushes", Always},
	{"mapped", MMAPOnly},
	{"vsize", Always},
	{"res", Always},
	{"non-mapped", MMAPOnly | AllOnly},
	{"faults", MMAPOnly},
	{"lr|lw %", MMAPOnly | AllOnly},
	{"lrt|lwt", MMAPOnly | AllOnly},
	{"    locked db", Locks},
	{"qr|qw", Always},
	{"ar|aw", Always},
	{"netIn", Always},
	{"netOut", Always},
	{"conn", Always},
	{"set", Repl},
	{"repl", Repl},
	{"time", Always},
}

StatHeaders are the complete set of data metrics supported by mongostat.

View Source 
var WiredTigerExtStats = map[string]string{
	"wtcache_tracked_dirty_bytes":          "TrackedDirtyBytes",
	"wtcache_current_bytes":                "CurrentCachedBytes",
	"wtcache_max_bytes_configured":         "MaxBytesConfigured",
	"wtcache_app_threads_page_read_count":  "AppThreadsPageReadCount",
	"wtcache_app_threads_page_read_time":   "AppThreadsPageReadTime",
	"wtcache_app_threads_page_write_count": "AppThreadsPageWriteCount",
	"wtcache_bytes_written_from":           "BytesWrittenFrom",
	"wtcache_bytes_read_into":              "BytesReadInto",
	"wtcache_pages_evicted_by_app_thread":  "PagesEvictedByAppThread",
	"wtcache_pages_queued_for_eviction":    "PagesQueuedForEviction",
	"wtcache_pages_read_into":              "PagesReadIntoCache",
	"wtcache_pages_requested_from":         "PagesRequestedFromCache",
	"wtcache_server_evicting_pages":        "ServerEvictingPages",
	"wtcache_worker_thread_evictingpages":  "WorkerThreadEvictingPages",
	"wtcache_internal_pages_evicted":       "InternalPagesEvicted",
	"wtcache_modified_pages_evicted":       "ModifiedPagesEvicted",
	"wtcache_unmodified_pages_evicted":     "UnmodifiedPagesEvicted",
}
View Source 
var WiredTigerStats = map[string]string{
	"percent_cache_dirty": "CacheDirtyPercent",
	"percent_cache_used":  "CacheUsedPercent",
}

Functions

func IsAuthorization 

func IsAuthorization(err error) bool

Types

type CacheStats 

type CacheStats struct {
	TrackedDirtyBytes         int64 `bson:"tracked dirty bytes in the cache"`
	CurrentCachedBytes        int64 `bson:"bytes currently in the cache"`
	MaxBytesConfigured        int64 `bson:"maximum bytes configured"`
	AppThreadsPageReadCount   int64 `bson:"application threads page read from disk to cache count"`
	AppThreadsPageReadTime    int64 `bson:"application threads page read from disk to cache time (usecs)"`
	AppThreadsPageWriteCount  int64 `bson:"application threads page write from cache to disk count"`
	AppThreadsPageWriteTime   int64 `bson:"application threads page write from cache to disk time (usecs)"`
	BytesWrittenFrom          int64 `bson:"bytes written from cache"`
	BytesReadInto             int64 `bson:"bytes read into cache"`
	PagesEvictedByAppThread   int64 `bson:"pages evicted by application threads"`
	PagesQueuedForEviction    int64 `bson:"pages queued for eviction"`
	PagesReadIntoCache        int64 `bson:"pages read into cache"`
	PagesRequestedFromCache   int64 `bson:"pages requested from the cache"`
	ServerEvictingPages       int64 `bson:"eviction server evicting pages"`
	WorkerThreadEvictingPages int64 `bson:"eviction worker thread evicting pages"`
	InternalPagesEvicted      int64 `bson:"internal pages evicted"`
	ModifiedPagesEvicted      int64 `bson:"modified pages evicted"`
	UnmodifiedPagesEvicted    int64 `bson:"unmodified pages evicted"`
}

CacheStats stores cache statistics for WiredTiger.

type ClientStats 

type ClientStats struct {
	Total   int64 `bson:"total"`
	Readers int64 `bson:"readers"`
	Writers int64 `bson:"writers"`
}

ClientStats stores the number of active read/write operations.

type ClusterStatus 

type ClusterStatus struct {
	JumboChunksCount int64
}

ClusterStatus stores information related to the whole cluster

type CollectionLockStatus 

type CollectionLockStatus struct {
	ReadAcquireWaitsPercentage  float64
	WriteAcquireWaitsPercentage float64
	ReadAcquireTimeMicros       int64
	WriteAcquireTimeMicros      int64
}

CollectionLockStatus stores a collection's lock statistics.

type ConcurrentTransStats 

type ConcurrentTransStats struct {
	Out int64 `bson:"out"`
}

type ConcurrentTransactions 

type ConcurrentTransactions struct {
	Write ConcurrentTransStats `bson:"write"`
	Read  ConcurrentTransStats `bson:"read"`
}

type ConnectionStats 

type ConnectionStats struct {
	Current      int64 `bson:"current"`
	Available    int64 `bson:"available"`
	TotalCreated int64 `bson:"total_created"`
}

ConnectionStats stores information related to incoming database connections.

type CursorStats 

type CursorStats struct {
	TimedOut int64            `bson:"timedOut"`
	Open     *OpenCursorStats `bson:"open"`
}

CursorStats stores information related to cursor metrics.

type DBRecordStats 

type DBRecordStats struct {
	AccessesNotInMemory       int64                     `bson:"accessesNotInMemory"`
	PageFaultExceptionsThrown int64                     `bson:"pageFaultExceptionsThrown"`
	DBRecordAccesses          map[string]RecordAccesses `bson:",inline"`
}

DBRecordStats stores data related to memory operations across databases.

type Db 

type Db struct {
	Name        string
	DbStatsData *DbStatsData
}

Db represent a single DB

type DbData 

type DbData struct {
	Name   string
	Fields map[string]interface{}
}

type DbStatLine 

type DbStatLine struct {
	Name        string
	Collections int64
	Objects     int64
	AvgObjSize  float64
	DataSize    int64
	StorageSize int64
	NumExtents  int64
	Indexes     int64
	IndexSize   int64
	Ok          int64
}

type DbStats 

type DbStats struct {
	Dbs []Db
}

DbStats stores stats from all dbs

type DbStatsData 

type DbStatsData struct {
	Db          string      `bson:"db"`
	Collections int64       `bson:"collections"`
	Objects     int64       `bson:"objects"`
	AvgObjSize  float64     `bson:"avgObjSize"`
	DataSize    int64       `bson:"dataSize"`
	StorageSize int64       `bson:"storageSize"`
	NumExtents  int64       `bson:"numExtents"`
	Indexes     int64       `bson:"indexes"`
	IndexSize   int64       `bson:"indexSize"`
	Ok          int64       `bson:"ok"`
	GleStats    interface{} `bson:"gleStats"`
}

DbStatsData stores stats from a db

type DocumentStats 

type DocumentStats struct {
	Deleted  int64 `bson:"deleted"`
	Inserted int64 `bson:"inserted"`
	Returned int64 `bson:"returned"`
	Updated  int64 `bson:"updated"`
}

DocumentStats stores information related to document metrics.

type DurStats 

type DurStats struct {
	Commits            int64 `bson:"commits"`
	JournaledMB        int64 `bson:"journaledMB"`
	WriteToDataFilesMB int64 `bson:"writeToDataFilesMB"`
	Compression        int64 `bson:"compression"`
	CommitsInWriteLock int64 `bson:"commitsInWriteLock"`
	EarlyCommits       int64 `bson:"earlyCommits"`
	TimeMs             DurTiming
}

DurStats stores information related to journaling statistics.

type DurTiming 

type DurTiming struct {
	Dt               int64 `bson:"dt"`
	PrepLogBuffer    int64 `bson:"prepLogBuffer"`
	WriteToJournal   int64 `bson:"writeToJournal"`
	WriteToDataFiles int64 `bson:"writeToDataFiles"`
	RemapPrivateView int64 `bson:"remapPrivateView"`
}

DurTiming stores information related to journaling.

type ExtraInfo 

type ExtraInfo struct {
	PageFaults *int64 `bson:"page_faults"`
}

ExtraInfo stores additional platform specific information.

type FlushStats 

type FlushStats struct {
	Flushes      int64     `bson:"flushes"`
	TotalMs      int64     `bson:"total_ms"`
	AverageMs    float64   `bson:"average_ms"`
	LastMs       int64     `bson:"last_ms"`
	LastFinished time.Time `bson:"last_finished"`
}

FlushStats stores information about memory flushes.

type GlobalLockStats 

type GlobalLockStats struct {
	TotalTime     int64        `bson:"totalTime"`
	LockTime      int64        `bson:"lockTime"`
	CurrentQueue  *QueueStats  `bson:"currentQueue"`
	ActiveClients *ClientStats `bson:"activeClients"`
}

GlobalLockStats stores information related locks in the MMAP storage engine.

type LockStats 

type LockStats struct {
	TimeLockedMicros    ReadWriteLockTimes `bson:"timeLockedMicros"`
	TimeAcquiringMicros ReadWriteLockTimes `bson:"timeAcquiringMicros"`

	// AcquireCount and AcquireWaitCount are new fields of the lock stats only populated on 3.0 or newer.
	// Typed as a pointer so that if it is nil, mongostat can assume the field is not populated
	// with real namespace data.
	AcquireCount     *ReadWriteLockTimes `bson:"acquireCount,omitempty"`
	AcquireWaitCount *ReadWriteLockTimes `bson:"acquireWaitCount,omitempty"`
}

LockStats stores information related to time spent acquiring/holding locks for a given database.

type LockStatus 

type LockStatus struct {
	DBName     string
	Percentage float64
	Global     bool
}

LockStatus stores a database's lock statistics.

type LockUsage 

type LockUsage struct {
	Namespace string
	Reads     int64
	Writes    int64
}

LockUsage stores information related to a namespace's lock usage.

type MemStats 

type MemStats struct {
	Bits              int64       `bson:"bits"`
	Resident          int64       `bson:"resident"`
	Virtual           int64       `bson:"virtual"`
	Supported         interface{} `bson:"supported"`
	Mapped            int64       `bson:"mapped"`
	MappedWithJournal int64       `bson:"mappedWithJournal"`
}

MemStats stores data related to memory statistics.

type MetricsStats 

type MetricsStats struct {
	TTL      *TTLStats      `bson:"ttl"`
	Cursor   *CursorStats   `bson:"cursor"`
	Document *DocumentStats `bson:"document"`
}

MetricsStats stores information related to metrics

type MongoDB 

type MongoDB struct {
	Servers []string
	Ssl     Ssl

	GatherPerdbStats bool
	tlsint.ClientConfig
	// contains filtered or unexported fields
}

func (*MongoDB) Description 

func (*MongoDB) Description() string

func (*MongoDB) Gather 

func (m *MongoDB) Gather(acc telegraf.Accumulator) error

Reads stats from all configured servers accumulates stats. Returns one of the errors encountered while gather stats (if any).

func (*MongoDB) SampleConfig 

func (m *MongoDB) SampleConfig() string

type MongoStatus 

type MongoStatus struct {
	SampleTime    time.Time
	ServerStatus  *ServerStatus
	ReplSetStatus *ReplSetStatus
	ClusterStatus *ClusterStatus
	DbStats       *DbStats
	ShardStats    *ShardStats
	OplogStats    *OplogStats
}

type MongodbData 

type MongodbData struct {
	StatLine      *StatLine
	Fields        map[string]interface{}
	Tags          map[string]string
	DbData        []DbData
	ShardHostData []DbData
}

func NewMongodbData 

func NewMongodbData(statLine *StatLine, tags map[string]string) *MongodbData

func (*MongodbData) AddDbStats 

func (d *MongodbData) AddDbStats()

func (*MongodbData) AddDefaultStats 

func (d *MongodbData) AddDefaultStats()

func (*MongodbData) AddShardHostStats 

func (d *MongodbData) AddShardHostStats()

type NamespacedLocks 

type NamespacedLocks map[string]LockStatus

NamespacedLocks stores information on the LockStatus of namespaces.

type NetworkStats 

type NetworkStats struct {
	BytesIn     int64 `bson:"bytesIn"`
	BytesOut    int64 `bson:"bytesOut"`
	NumRequests int64 `bson:"numRequests"`
}

NetworkStats stores information related to network traffic.

type OpcountStats 

type OpcountStats struct {
	Insert  int64 `bson:"insert"`
	Query   int64 `bson:"query"`
	Update  int64 `bson:"update"`
	Delete  int64 `bson:"delete"`
	GetMore int64 `bson:"getmore"`
	Command int64 `bson:"command"`
}

OpcountStats stores information related to comamnds and basic CRUD operations.

type OpenCursorStats 

type OpenCursorStats struct {
	NoTimeout int64 `bson:"noTimeout"`
	Pinned    int64 `bson:"pinned"`
	Total     int64 `bson:"total"`
}

OpenCursorStats stores information related to open cursor metrics

type OplogStats 

type OplogStats struct {
	TimeDiff int64
}

OplogStatus stores information from getReplicationInfo

type QueueStats 

type QueueStats struct {
	Total   int64 `bson:"total"`
	Readers int64 `bson:"readers"`
	Writers int64 `bson:"writers"`
}

QueueStats stores the number of queued read/write operations.

type ReadWriteLockTimes 

type ReadWriteLockTimes struct {
	Read       int64 `bson:"R"`
	Write      int64 `bson:"W"`
	ReadLower  int64 `bson:"r"`
	WriteLower int64 `bson:"w"`
}

ReadWriteLockTimes stores time spent holding read/write locks.

type RecordAccesses 

type RecordAccesses struct {
	AccessesNotInMemory       int64 `bson:"accessesNotInMemory"`
	PageFaultExceptionsThrown int64 `bson:"pageFaultExceptionsThrown"`
}

RecordAccesses stores data related to memory operations scoped to a database.

type ReplSetMember 

type ReplSetMember struct {
	Name       string    `bson:"name"`
	State      int64     `bson:"state"`
	StateStr   string    `bson:"stateStr"`
	OptimeDate time.Time `bson:"optimeDate"`
}

ReplSetMember stores information related to a replica set member

type ReplSetStatus 

type ReplSetStatus struct {
	Members []ReplSetMember `bson:"members"`
	MyState int64           `bson:"myState"`
}

ReplSetStatus stores information from replSetGetStatus

type ReplStatus 

type ReplStatus struct {
	SetName      interface{} `bson:"setName"`
	IsMaster     interface{} `bson:"ismaster"`
	Secondary    interface{} `bson:"secondary"`
	IsReplicaSet interface{} `bson:"isreplicaset"`
	ArbiterOnly  interface{} `bson:"arbiterOnly"`
	Hosts        []string    `bson:"hosts"`
	Passives     []string    `bson:"passives"`
	Me           string      `bson:"me"`
}

ReplStatus stores data related to replica sets.

type Server 

type Server struct {
	Url     *url.URL
	Session *mgo.Session
	// contains filtered or unexported fields
}

type ServerStatus 

type ServerStatus struct {
	Host               string                 `bson:"host"`
	Version            string                 `bson:"version"`
	Process            string                 `bson:"process"`
	Pid                int64                  `bson:"pid"`
	Uptime             int64                  `bson:"uptime"`
	UptimeMillis       int64                  `bson:"uptimeMillis"`
	UptimeEstimate     int64                  `bson:"uptimeEstimate"`
	LocalTime          time.Time              `bson:"localTime"`
	Asserts            map[string]int64       `bson:"asserts"`
	BackgroundFlushing *FlushStats            `bson:"backgroundFlushing"`
	ExtraInfo          *ExtraInfo             `bson:"extra_info"`
	Connections        *ConnectionStats       `bson:"connections"`
	Dur                *DurStats              `bson:"dur"`
	GlobalLock         *GlobalLockStats       `bson:"globalLock"`
	Locks              map[string]LockStats   `bson:"locks,omitempty"`
	Network            *NetworkStats          `bson:"network"`
	Opcounters         *OpcountStats          `bson:"opcounters"`
	OpcountersRepl     *OpcountStats          `bson:"opcountersRepl"`
	RecordStats        *DBRecordStats         `bson:"recordStats"`
	Mem                *MemStats              `bson:"mem"`
	Repl               *ReplStatus            `bson:"repl"`
	ShardCursorType    map[string]interface{} `bson:"shardCursorType"`
	StorageEngine      map[string]string      `bson:"storageEngine"`
	WiredTiger         *WiredTiger            `bson:"wiredTiger"`
	Metrics            *MetricsStats          `bson:"metrics"`
}

type ShardHostStatLine 

type ShardHostStatLine struct {
	InUse      int64
	Available  int64
	Created    int64
	Refreshing int64
}

type ShardHostStatsData 

type ShardHostStatsData struct {
	InUse      int64 `bson:"inUse"`
	Available  int64 `bson:"available"`
	Created    int64 `bson:"created"`
	Refreshing int64 `bson:"refreshing"`
}

ShardHostStatsData is the host-specific stats from shardConnPoolStats database command.

type ShardStats 

type ShardStats struct {
	ShardStatsData `bson:",inline"`
	Hosts          map[string]ShardHostStatsData `bson:"hosts"`
}

ShardStats stores information from shardConnPoolStats.

type ShardStatsData 

type ShardStatsData struct {
	TotalInUse      int64 `bson:"totalInUse"`
	TotalAvailable  int64 `bson:"totalAvailable"`
	TotalCreated    int64 `bson:"totalCreated"`
	TotalRefreshing int64 `bson:"totalRefreshing"`
}

ShardStatsData is the total Shard Stats from shardConnPoolStats database command.

type Ssl 

type Ssl struct {
	Enabled bool
	CaCerts []string `toml:"cacerts"`
}

type StatHeader 

type StatHeader struct {
	// The text to appear in the column's header cell
	HeaderText string

	// Bitmask containing flags to determine if this header is active or not
	ActivateFlags int
}

StatHeader describes a single column for mongostat's terminal output, its formatting, and in which modes it should be displayed.

type StatLine 

type StatLine struct {
	Key string
	// What storage engine is being used for the node with this stat line
	StorageEngine string

	Error    error
	IsMongos bool
	Host     string

	// The time at which this StatLine was generated.
	Time time.Time

	// The last time at which this StatLine was printed to output.
	LastPrinted time.Time

	// Opcounter fields
	Insert, InsertCnt   int64
	Query, QueryCnt     int64
	Update, UpdateCnt   int64
	Delete, DeleteCnt   int64
	GetMore, GetMoreCnt int64
	Command, CommandCnt int64

	// TTL fields
	Passes, PassesCnt                     int64
	DeletedDocuments, DeletedDocumentsCnt int64

	// Cursor fields
	TimedOutC, TimedOutCCnt   int64
	NoTimeoutC, NoTimeoutCCnt int64
	PinnedC, PinnedCCnt       int64
	TotalC, TotalCCnt         int64

	// Document fields
	DeletedD, InsertedD, ReturnedD, UpdatedD int64

	// Connection fields
	CurrentC, AvailableC, TotalCreatedC int64

	// Collection locks (3.0 mmap only)
	CollectionLocks *CollectionLockStatus

	// Cache utilization (wiredtiger only)
	CacheDirtyPercent float64
	CacheUsedPercent  float64

	// Cache ultilization extended (wiredtiger only)
	TrackedDirtyBytes         int64
	CurrentCachedBytes        int64
	MaxBytesConfigured        int64
	AppThreadsPageReadCount   int64
	AppThreadsPageReadTime    int64
	AppThreadsPageWriteCount  int64
	BytesWrittenFrom          int64
	BytesReadInto             int64
	PagesEvictedByAppThread   int64
	PagesQueuedForEviction    int64
	PagesReadIntoCache        int64
	PagesRequestedFromCache   int64
	ServerEvictingPages       int64
	WorkerThreadEvictingPages int64
	InternalPagesEvicted      int64
	ModifiedPagesEvicted      int64
	UnmodifiedPagesEvicted    int64

	// Replicated Opcounter fields
	InsertR, InsertRCnt                  int64
	QueryR, QueryRCnt                    int64
	UpdateR, UpdateRCnt                  int64
	DeleteR, DeleteRCnt                  int64
	GetMoreR, GetMoreRCnt                int64
	CommandR, CommandRCnt                int64
	ReplLag                              int64
	OplogTimeDiff                        int64
	Flushes, FlushesCnt                  int64
	FlushesTotalTime                     int64
	Mapped, Virtual, Resident, NonMapped int64
	Faults, FaultsCnt                    int64
	HighestLocked                        *LockStatus
	QueuedReaders, QueuedWriters         int64
	ActiveReaders, ActiveWriters         int64
	NetIn, NetInCnt                      int64
	NetOut, NetOutCnt                    int64
	NumConnections                       int64
	ReplSetName                          string
	NodeType                             string
	NodeState                            string

	// Cluster fields
	JumboChunksCount int64

	// DB stats field
	DbStatsLines []DbStatLine

	// Shard stats
	TotalInUse, TotalAvailable, TotalCreated, TotalRefreshing int64

	// Shard Hosts stats field
	ShardHostStatsLines map[string]ShardHostStatLine
}

StatLine is a wrapper for all metrics reported by mongostat for monitored hosts.

func NewStatLine 

func NewStatLine(oldMongo, newMongo MongoStatus, key string, all bool, sampleSecs int64) *StatLine

NewStatLine constructs a StatLine object from two MongoStatus objects.

type TTLStats 

type TTLStats struct {
	DeletedDocuments int64 `bson:"deletedDocuments"`
	Passes           int64 `bson:"passes"`
}

TTLStats stores information related to documents with a ttl index.

type TransactionStats 

type TransactionStats struct {
	TransCheckpointsTotalTimeMsecs int64 `bson:"transaction checkpoint total time (msecs)"`
	TransCheckpoints               int64 `bson:"transaction checkpoints"`
}

TransactionStats stores transaction checkpoints in WiredTiger.

type WiredTiger 

type WiredTiger struct {
	Transaction TransactionStats       `bson:"transaction"`
	Concurrent  ConcurrentTransactions `bson:"concurrentTransactions"`
	Cache       CacheStats             `bson:"cache"`
}

WiredTiger stores information related to the WiredTiger storage engine.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.