func NewRethinkDBExporter(addr, auth, clusterName, namespace string) *Exporter {
return &Exporter{
addrs: strings.Split(addr, ","),
auth: auth,
clusterName: clusterName,
namespace: namespace,
duration: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Name: "exporter_last_scrape_duration_seconds",
Help: "The last scrape duration.",
}),
totalScrapes: prometheus.NewCounter(prometheus.CounterOpts{
Namespace: namespace,
Name: "exporter_scrapes_total",
Help: "Current total rethinkdb scrapes.",
}),
scrapeError: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Name: "exporter_last_scrape_error",
Help: "The last scrape error status.",
}),
metrics: map[string]*prometheus.GaugeVec{},
}
}
// NewExporter returns a new PostgreSQL exporter for the provided DSN.
func NewExporter(dsn string, userQueriesPath string) *Exporter {
return &Exporter{
dsn: dsn,
userQueriesPath: userQueriesPath,
duration: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: exporter,
Name: "last_scrape_duration_seconds",
Help: "Duration of the last scrape of metrics from PostgresSQL.",
}),
totalScrapes: prometheus.NewCounter(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: exporter,
Name: "scrapes_total",
Help: "Total number of times PostgresSQL was scraped for metrics.",
}),
error: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: exporter,
Name: "last_scrape_error",
Help: "Whether the last scrape of metrics from PostgreSQL resulted in an error (1 for error, 0 for success).",
}),
variableMap: nil,
metricMap: nil,
queryOverrides: nil,
}
}
func registerProbes() {
for _, probe := range config.Probes {
probeURL, _ := url.Parse(probe)
monitors := &probeMonitor{}
monitors.Expires = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "certcheck_expires",
Help: "Expiration date in unix timestamp (UTC)",
ConstLabels: prometheus.Labels{
"host": probeURL.Host,
},
})
monitors.IsValid = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "certcheck_valid",
Help: "Validity of the certificate (0/1)",
ConstLabels: prometheus.Labels{
"host": probeURL.Host,
},
})
prometheus.MustRegister(monitors.Expires)
prometheus.MustRegister(monitors.IsValid)
probeMonitors[probeURL.Host] = monitors
}
}
func NewRedisExporter(addrs []string, namespace string) *Exporter {
e := Exporter{
addrs: addrs,
namespace: namespace,
duration: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Name: "exporter_last_scrape_duration_seconds",
Help: "The last scrape duration.",
}),
totalScrapes: prometheus.NewCounter(prometheus.CounterOpts{
Namespace: namespace,
Name: "exporter_scrapes_total",
Help: "Current total redis scrapes.",
}),
scrapeErrors: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Name: "exporter_last_scrape_error",
Help: "The last scrape error status.",
}),
}
e.initGauges()
return &e
}
// NewClusterUsageCollector creates and returns the reference to ClusterUsageCollector
// and internally defines each metric that display cluster stats.
func NewClusterUsageCollector(conn Conn) *ClusterUsageCollector {
return &ClusterUsageCollector{
conn: conn,
GlobalCapacity: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: cephNamespace,
Name: "cluster_capacity_bytes",
Help: "Total capacity of the cluster",
}),
UsedCapacity: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: cephNamespace,
Name: "cluster_used_bytes",
Help: "Capacity of the cluster currently in use",
}),
AvailableCapacity: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: cephNamespace,
Name: "cluster_available_bytes",
Help: "Available space within the cluster",
}),
Objects: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: cephNamespace,
Name: "cluster_objects",
Help: "No. of rados objects within the cluster",
}),
}
}
func startMonitoring(addr string) {
var redisActiveConn = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "redis_active_conn",
Help: "Number of active redis connections.",
})
prometheus.MustRegister(redisActiveConn)
var redisMaxConn = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "redis_max_conn",
Help: "Maximum number of redis connections.",
})
prometheus.MustRegister(redisMaxConn)
http.Handle("/metrics", prometheus.Handler())
redisMaxConn.Set(float64(redisPool.MaxActive))
go func() {
tick := time.NewTicker(1 * time.Second)
for range tick.C {
if redisPool == nil {
redisActiveConn.Set(0)
} else {
redisActiveConn.Set(float64(redisPool.ActiveCount()))
}
}
}()
err := http.ListenAndServe(addr, nil)
if err != nil {
lg.Fatal(err)
}
}
// NewExporter returns a new MySQL exporter for the provided DSN.
func NewExporter(dsn string) *Exporter {
return &Exporter{
dsn: dsn,
duration: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: exporter,
Name: "last_scrape_duration_seconds",
Help: "Duration of the last scrape of metrics from MySQL.",
}),
totalScrapes: prometheus.NewCounter(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: exporter,
Name: "scrapes_total",
Help: "Total number of times MySQL was scraped for metrics.",
}),
scrapeErrors: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: exporter,
Name: "scrape_errors_total",
Help: "Total number of times an error occurred scraping a MySQL.",
}, []string{"collector"}),
error: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: exporter,
Name: "last_scrape_error",
Help: "Whether the last scrape of metrics from MySQL resulted in an error (1 for error, 0 for success).",
}),
mysqldUp: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Name: "up",
Help: "Whether the MySQL server is up.",
}),
}
}
func NewPostgreSQLExporter(dsn string, cq []metrics.CustomQuery) *Exporter {
e := &Exporter{
dsn: dsn,
metrics: []metrics.Collection{
metrics.NewBufferMetrics(),
metrics.NewDBMetrics(strings.Split(*databases, ",")),
metrics.NewSlowQueryMetrics(*slow),
metrics.NewCustomQueryMetrics(cq),
},
totalScrapes: prometheus.NewCounter(prometheus.CounterOpts{
Namespace: namespace,
Name: "exporter_scrapes_total",
Help: "Current total postgresql scrapes.",
}),
duration: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Name: "exporter_last_scrape_duration_seconds",
Help: "The last scrape duration.",
}),
errors: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Name: "exporter_last_scrape_error",
Help: "The last scrape error status.",
}),
}
if len(*tables) > 0 {
e.metrics = append(e.metrics, metrics.NewTableMetrics(strings.Split(*tables, ",")))
}
return e
}
func initPrometheusMetrics() {
TotalClientCounter = stat.NewGauge(stat.GaugeOpts{
Name: "total_clients",
Help: "Total number of connected clients",
})
TotalNodes = stat.NewGauge(stat.GaugeOpts{
Name: "meshnodes_total",
Help: "Total number of Nodes",
})
TotalNodeTrafficRx = stat.NewCounter(stat.CounterOpts{
Name: "total_traffic_rx",
Help: "Total accumulated received traffic as reported by Nodes",
})
TotalNodeTrafficTx = stat.NewCounter(stat.CounterOpts{
Name: "total_traffic_tx",
Help: "Total accumulated transmitted traffic as reported by Nodes",
})
TotalNodeMgmtTrafficRx = stat.NewCounter(stat.CounterOpts{
Name: "total_traffic_mgmt_rx",
Help: "Total accumulated received management traffic as reported by Nodes",
})
TotalNodeMgmtTrafficTx = stat.NewCounter(stat.CounterOpts{
Name: "total_traffic_mgmt_tx",
Help: "Total accumulated transmitted management traffic as reported by Nodes",
})
OnlineNodes = stat.NewGauge(stat.GaugeOpts{
Name: "meshnodes_online_total",
Help: "All online nodes",
})
NodesTrafficRx = stat.NewCounterVec(stat.CounterOpts{
Name: "meshnode_traffic_rx",
Help: "Transmitted traffic from nodes",
}, append(nodeLabels, "type"))
NodesTrafficTx = stat.NewCounterVec(stat.CounterOpts{
Name: "meshnode_traffic_tx",
Help: "Received traffic on nodes",
}, append(nodeLabels, "type"))
NodesUptime = stat.NewCounterVec(stat.CounterOpts{
Name: "meshnode_uptime",
Help: "Uptime of meshnodes",
}, nodeLabels)
NodesClients = stat.NewGaugeVec(stat.GaugeOpts{
Name: "meshnode_clients",
Help: "Clients on single meshnodes",
}, nodeLabels)
}
// NewMgoStatsCollector creates a MgoStatsCollector for the given
// namespace (which may be empty).
func NewMgoStatsCollector(namespace string) *MgoStatsCollector {
// Enable stats in the mgo driver.
mgo.SetStats(true)
return &MgoStatsCollector{
clusters: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: "mgo",
Name: "clusters",
Help: "Number of alive clusters.",
}),
masterConns: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: "mgo",
Name: "master_connections",
Help: "Number of master connections.",
}),
slaveConns: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: "mgo",
Name: "slave_connections",
Help: "Number of slave connections.",
}),
sentOps: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: "mgo",
Name: "sent_operations",
Help: "Number of operations sent.",
}),
receivedOps: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: "mgo",
Name: "received_operations",
Help: "Number of operations received.",
}),
receivedDocs: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: "mgo",
Name: "received_documents",
Help: "Number of documents received.",
}),
socketsAlive: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: "mgo",
Name: "sockets_alive",
Help: "Number of alive sockets.",
}),
socketsInUse: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: "mgo",
Name: "sockets_in_use",
Help: "Number of in use sockets.",
}),
socketRefs: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: "mgo",
Name: "socket_references",
Help: "Number of references to sockets.",
}),
}
}
func defineDnsmasqMetrics(options *Options) {
const dnsmasqSubsystem = "dnsmasq"
gauges[dnsmasq.CacheHits] = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: options.PrometheusNamespace,
Subsystem: dnsmasqSubsystem,
Name: "hits",
Help: "Number of DNS cache hits (from start of process)",
})
gauges[dnsmasq.CacheMisses] = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: options.PrometheusNamespace,
Subsystem: dnsmasqSubsystem,
Name: "misses",
Help: "Number of DNS cache misses (from start of process)",
})
gauges[dnsmasq.CacheEvictions] = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: options.PrometheusNamespace,
Subsystem: dnsmasqSubsystem,
Name: "evictions",
Help: "Counter of DNS cache evictions (from start of process)",
})
gauges[dnsmasq.CacheInsertions] = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: options.PrometheusNamespace,
Subsystem: dnsmasqSubsystem,
Name: "insertions",
Help: "Counter of DNS cache insertions (from start of process)",
})
gauges[dnsmasq.CacheSize] = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: options.PrometheusNamespace,
Subsystem: dnsmasqSubsystem,
Name: "max_size",
Help: "Maximum size of the DNS cache",
})
for i := range gauges {
prometheus.MustRegister(gauges[i])
}
errorsCounter = prometheus.NewCounter(
prometheus.CounterOpts{
Namespace: options.PrometheusNamespace,
Subsystem: dnsmasqSubsystem,
Name: "errors",
Help: "Number of errors that have occurred getting metrics",
})
prometheus.MustRegister(errorsCounter)
}
func (n *Namespace) NewGauge(name, help string, unit Unit) Gauge {
g := &gauge{
pg: prometheus.NewGauge(n.newGaugeOpts(name, help, unit)),
}
n.addMetric(g)
return g
}
func metricsInit(servicename string) *syndicateMetrics {
m := syndicateMetrics{}
m.managedNodes = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "ManagedNodes",
Help: "Current number of nodes managed.",
ConstLabels: prometheus.Labels{"servicename": servicename},
})
m.subscriberNodes = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "SubscriberNodes",
Help: "Current number of unmanaged nodes subscribed for ring changes.",
ConstLabels: prometheus.Labels{"servicename": servicename},
})
prometheus.Register(m.managedNodes)
prometheus.Register(m.subscriberNodes)
return &m
}
func (c *netStatCollector) Update(ch chan<- prometheus.Metric) (err error) {
netStats, err := getNetStats()
if err != nil {
return fmt.Errorf("couldn't get netstats: %s", err)
}
for protocol, protocolStats := range netStats {
for name, value := range protocolStats {
key := protocol + "_" + name
if _, ok := c.metrics[key]; !ok {
c.metrics[key] = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: netStatsSubsystem,
Name: key,
Help: fmt.Sprintf("%s %s from /proc/net/netstat.", protocol, name),
},
)
}
v, err := strconv.ParseFloat(value, 64)
if err != nil {
return fmt.Errorf("invalid value %s in netstats: %s", value, err)
}
c.metrics[key].Set(v)
}
}
for _, m := range c.metrics {
m.Collect(ch)
}
return err
}
func TestSensorRecordGauge(t *testing.T) {
testServer := httptest.NewServer(prometheus.UninstrumentedHandler())
defer testServer.Close()
sensor := &Sensor{
Type: "gauge",
collector: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: "telemetry",
Subsystem: "sensors",
Name: "TestSensorRecordGauge",
Help: "help",
})}
prometheus.MustRegister(sensor.collector)
sensor.record("1.2")
resp := getFromTestServer(t, testServer)
if strings.Count(resp, "telemetry_sensors_TestSensorRecordGauge 1.2") != 1 {
t.Fatalf("Failed to get match for sensor in response: %s", resp)
}
sensor.record("2.3")
resp = getFromTestServer(t, testServer)
if strings.Count(resp, "telemetry_sensors_TestSensorRecordGauge 2.3") != 1 {
t.Fatalf("Failed to get match for sensor in response: %s", resp)
}
}
func (c *fileFDStatCollector) Update(ch chan<- prometheus.Metric) (err error) {
fileFDStat, err := getFileFDStats(procFilePath("sys/fs/file-nr"))
if err != nil {
return fmt.Errorf("couldn't get file-nr: %s", err)
}
for name, value := range fileFDStat {
if _, ok := c.metrics[name]; !ok {
c.metrics[name] = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: fileFDStatSubsystem,
Name: name,
Help: fmt.Sprintf("File descriptor statistics: %s.", name),
},
)
}
v, err := strconv.ParseFloat(value, 64)
if err != nil {
return fmt.Errorf("invalid value %s in file-nr: %s", value, err)
}
c.metrics[name].Set(v)
}
for _, m := range c.metrics {
m.Collect(ch)
}
return err
}
func New(configFile string) (e exporter, err error) {
e = exporter{
configFile: configFile,
Metrics: map[string]*prometheus.GaugeVec{},
scrapeDuration: prometheus.NewSummaryVec(
prometheus.SummaryOpts{
Namespace: namespace,
Name: "scrape_duration_seconds",
Help: "gmond_exporter: Duration of a scrape job.",
},
[]string{"endpoint", "result"},
),
metricsUpdated: prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Namespace: namespace,
Name: "metrics_updated_count",
Help: "gmond_exporter: Number of metrics updated.",
},
[]string{"endpoint"},
),
metricsExported: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Name: "metrics_exported_count",
Help: "gmond_exporter: Number of metrics exported.",
}),
configChan: make(chan config),
listeningAddress: ":8080",
gangliaScrapeInterval: 60 * time.Second,
}
conf, err := e.readConfig()
if err != nil {
return e, fmt.Errorf("Couldn't read config: %s", err)
}
e.conf = conf
if conf.ListeningAddress != "" {
e.listeningAddress = conf.ListeningAddress
}
if conf.GangliaScrapeInterval != 0 {
e.gangliaScrapeInterval = time.Duration(conf.GangliaScrapeInterval) * time.Second
}
prometheus.MustRegister(e.scrapeDuration)
prometheus.MustRegister(e.metricsUpdated)
prometheus.MustRegister(e.metricsExported)
debug("Registered internal metrics")
sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGHUP)
go func() {
for _ = range sig {
e.reloadConfig() // sends a new config to configChan
}
}()
go e.serveStatus()
return e, nil
}
func main() {
log.SetFlags(log.LstdFlags | log.Lshortfile)
flag.Parse()
if !*runBackup && !*runSync {
log.Fatal("Neither -backup nor -sync enabled, nothing to do.")
}
storageList := strings.Split(*storageHosts, ",")
if len(storageList) > 2 {
log.Fatal("More than 2 -storage_hosts are not supported. Please send a patch to fix.")
}
if *runBackup {
backup(storageList)
}
if *runSync {
sync(storageList)
}
lastSuccess := prometheus.NewGauge(prometheus.GaugeOpts{
Name: "last_success",
Help: "Timestamp of the last success",
})
prometheus.MustRegister(lastSuccess)
lastSuccess.Set(float64(time.Now().Unix()))
if err := prometheus.Push("dornroeschen", "dornroeschen", *pushGateway); err != nil {
log.Fatal(err)
}
}
func (c *sockStatCollector) Update(ch chan<- prometheus.Metric) (err error) {
sockStats, err := getSockStats(procFilePath("net/sockstat"))
if err != nil {
return fmt.Errorf("couldn't get sockstats: %s", err)
}
for protocol, protocolStats := range sockStats {
for name, value := range protocolStats {
key := protocol + "_" + name
if _, ok := c.metrics[key]; !ok {
c.metrics[key] = prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: sockStatSubsystem,
Name: key,
Help: fmt.Sprintf("Number of %s sockets in state %s.", protocol, name),
},
)
}
v, err := strconv.ParseFloat(value, 64)
if err != nil {
return fmt.Errorf("invalid value %s in sockstats: %s", value, err)
}
c.metrics[key].Set(v)
}
}
for _, m := range c.metrics {
m.Collect(ch)
}
return err
}
func (c miniCollector) Describe(ch chan<- *prometheus.Desc) {
prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: "fake",
Subsystem: "fake",
Name: "fake",
Help: "fake",
}).Describe(ch)
}
func newAuroraExporter(f finder) *exporter {
return &exporter{
f: f,
errors: prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: namespace,
Name: "exporter_scrape_errors_total",
Help: "Total scrape errors",
}),
duration: prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: namespace,
Name: "exporter_last_scrape_duration_seconds",
Help: "The last scrape duration",
}),
}
}
func exampleInit(c *cli.Context, reg *harness.MetricRegistry) (harness.Collector, error) {
fooEnabled := c.Bool("flagfoo")
if fooEnabled {
fmt.Println("foo enabled")
}
reg.Register("example_metric_A", prometheus.NewGauge(prometheus.GaugeOpts{
Name: "example_metric_A",
Help: "is example_metric_A",
}))
reg.Register("example_metric_B", prometheus.NewGauge(prometheus.GaugeOpts{
Name: "example_metric_B",
Help: "is example_metric_B",
}))
return &collector{}, nil
}
func WritePrometheusMetrics(logger *log.Logger, PROM_GATEWAY string, HOST string, metrics []Metric) error {
var err error
logger.Printf("writing %d metrics\n", len(metrics))
for i := 0; i < len(metrics); i++ {
//metrics[i].Print()
opts := prometheus.GaugeOpts{
Name: PREFIX + metrics[i].MetricName,
Help: "no help available",
}
labels := make(map[string]string)
labels["DatabaseName"] = metrics[i].DatabaseName
labels["Units"] = metrics[i].Units
if metrics[i].TableName != "" {
labels["TableName"] = metrics[i].TableName
}
if metrics[i].LockType != "" {
labels["LockType"] = metrics[i].LockType
labels["LockMode"] = metrics[i].LockMode
}
if metrics[i].LastVacuum != "" {
labels["LastVacuum"] = metrics[i].LastVacuum
labels["LastAnalyze"] = metrics[i].LastAnalyze
labels["AvNeeded"] = metrics[i].AvNeeded
}
if metrics[i].Age != "" {
labels["Age"] = metrics[i].Age
labels["Kind"] = metrics[i].Kind
}
if metrics[i].MetricName == "wraparound" {
labels["TableSz"] = strconv.FormatInt(metrics[i].TableSz, 10)
labels["TotalSz"] = strconv.FormatInt(metrics[i].TotalSz, 10)
}
if metrics[i].MetricName == "pct_dead" {
labels["DeadTup"] = strconv.FormatInt(metrics[i].DeadTup, 10)
labels["RelTup"] = strconv.FormatInt(metrics[i].RelTup, 10)
labels["TableSz"] = strconv.FormatInt(metrics[i].TableSz, 10)
labels["TotalSz"] = strconv.FormatInt(metrics[i].TotalSz, 10)
}
opts.ConstLabels = labels
newMetric := prometheus.NewGauge(opts)
newMetric.Set(float64(metrics[i].Value))
if err := prometheus.PushCollectors(
metrics[i].MetricName, HOST,
PROM_GATEWAY,
newMetric,
); err != nil {
logger.Println("Could not push " + metrics[i].MetricName + "completion time to Pushgateway:" + err.Error())
return err
}
}
return err
}
// return new empty exporter
func NewMySQLExporter(dsn string) *Exporter {
return &Exporter{
dsn: dsn,
duration: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Name: "exporter_last_scrape_duration_seconds",
Help: "The last scrape duration.",
}),
totalScrapes: prometheus.NewCounter(prometheus.CounterOpts{
Namespace: namespace,
Name: "exporter_scrapes_total",
Help: "Current total mysqld scrapes.",
}),
error: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Name: "exporter_last_scrape_error",
Help: "The last scrape error status.",
}),
metrics: map[string]prometheus.Gauge{},
commands: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: globalStatus,
Name: "commands_total",
Help: "Number of executed mysql commands.",
}, []string{"command"}),
connectionErrors: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: globalStatus,
Name: "connection_errors_total",
Help: "Number of mysql connection errors.",
}, []string{"error"}),
innodbRows: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: globalStatus,
Name: "innodb_rows_total",
Help: "Mysql Innodb row operations.",
}, []string{"operation"}),
performanceSchema: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: globalStatus,
Name: "performance_schema_total",
Help: "Mysql instrumentations that could not be loaded or created due to memory constraints",
}, []string{"instrumentation"}),
}
}
// Takes a prometheus registry and returns a new Collector exposing
// load1 stat.
func NewLoadavgCollector() (Collector, error) {
return &loadavgCollector{
metric: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Name: "load1",
Help: "1m load average.",
}),
}, nil
}
// New constructs a neww Notifier.
func New(o *Options) *Notifier {
ctx, cancel := context.WithCancel(context.Background())
return &Notifier{
queue: make(model.Alerts, 0, o.QueueCapacity),
ctx: ctx,
cancel: cancel,
more: make(chan struct{}, 1),
opts: o,
latency: prometheus.NewSummaryVec(prometheus.SummaryOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: "latency_seconds",
Help: "Latency quantiles for sending alert notifications (not including dropped notifications).",
},
[]string{alertmanagerLabel},
),
errors: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: "errors_total",
Help: "Total number of errors sending alert notifications.",
},
[]string{alertmanagerLabel},
),
sent: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: "sent_total",
Help: "Total number of alerts successfully sent.",
},
[]string{alertmanagerLabel},
),
dropped: prometheus.NewCounter(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: "dropped_total",
Help: "Total number of alerts dropped due to alert manager missing in configuration.",
}),
queueLength: prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: "queue_length",
Help: "The number of alert notifications in the queue.",
}),
queueCapacity: prometheus.MustNewConstMetric(
prometheus.NewDesc(
prometheus.BuildFQName(namespace, subsystem, "queue_capacity"),
"The capacity of the alert notifications queue.",
nil, nil,
),
prometheus.GaugeValue,
float64(o.QueueCapacity),
),
}
}
func (_ prometheusMetricsProvider) NewDepthMetric(name string) workqueue.GaugeMetric {
depth := prometheus.NewGauge(prometheus.GaugeOpts{
Subsystem: name,
Name: "depth",
Help: "Current depth of workqueue: " + name,
})
prometheus.Register(depth)
return depth
}
// NewSensors creates new sensors from a raw config
func NewSensors(raw []interface{}) ([]*Sensor, error) {
var sensors []*Sensor
if err := utils.DecodeRaw(raw, &sensors); err != nil {
return nil, fmt.Errorf("Sensor configuration error: %v", err)
}
for _, s := range sensors {
check, err := commands.NewCommand(s.CheckExec, s.Timeout)
if err != nil {
return nil, fmt.Errorf("could not parse check in sensor %s: %s", s.Name, err)
}
check.Name = fmt.Sprintf("%s.sensor", s.Name)
s.checkCmd = check
// the prometheus client lib's API here is baffling... they don't expose
// an interface or embed their Opts type in each of the Opts "subtypes",
// so we can't share the initialization.
switch {
case s.Type == "counter":
s.collector = prometheus.NewCounter(prometheus.CounterOpts{
Namespace: s.Namespace,
Subsystem: s.Subsystem,
Name: s.Name,
Help: s.Help,
})
case s.Type == "gauge":
s.collector = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: s.Namespace,
Subsystem: s.Subsystem,
Name: s.Name,
Help: s.Help,
})
case s.Type == "histogram":
s.collector = prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: s.Namespace,
Subsystem: s.Subsystem,
Name: s.Name,
Help: s.Help,
})
case s.Type == "summary":
s.collector = prometheus.NewSummary(prometheus.SummaryOpts{
Namespace: s.Namespace,
Subsystem: s.Subsystem,
Name: s.Name,
Help: s.Help,
})
default:
return nil, fmt.Errorf("invalid sensor type: %s", s.Type)
}
// we're going to unregister before every attempt to register
// so that we can reload config
prometheus.Unregister(s.collector)
if err := prometheus.Register(s.collector); err != nil {
return nil, err
}
}
return sensors, nil
}
func newMetric(metricName string, docString string) prometheus.Gauge {
return prometheus.NewGauge(
prometheus.GaugeOpts{
Namespace: namespace,
Name: metricName,
Help: docString,
},
)
}
// NewExporter returns an initialized exporter
func NewExporter(server string) *Exporter {
return &Exporter{
mc: memcache.New(server),
up: prometheus.NewGauge(
prometheus.GaugeOpts{
Name: "up",
Namespace: namespace,
Help: "Are the servers up.",
ConstLabels: prometheus.Labels{"server": server},
},
),
uptime: prometheus.NewCounter(
prometheus.CounterOpts{
Name: "uptime",
Namespace: namespace,
Help: "The uptime of the server.",
ConstLabels: prometheus.Labels{"server": server},
},
),
cache: prometheus.NewCounterVec(
prometheus.CounterOpts{
Name: "cache",
Namespace: namespace,
Help: "The cache hits/misses broken down by command (get, set, etc.).",
ConstLabels: prometheus.Labels{"server": server},
},
[]string{"command", "status"},
),
usage: prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Name: "usage",
Namespace: namespace,
Help: "Details the resource usage (items/connections) of the server, by time (current/total).",
ConstLabels: prometheus.Labels{"server": server},
},
[]string{"time", "resource"},
),
bytes: prometheus.NewCounterVec(
prometheus.CounterOpts{
Name: "bytes",
Namespace: namespace,
Help: "The bytes sent/received by the server.",
ConstLabels: prometheus.Labels{"server": server},
},
[]string{"direction"},
),
removals: prometheus.NewCounterVec(
prometheus.CounterOpts{
Name: "removal",
Namespace: namespace,
Help: "Number of items that have been evicted/expired (status), and if the were fetched ever or not.",
ConstLabels: prometheus.Labels{"server": server},
},
[]string{"status", "fetched"},
),
}
}
