func (e *Exporter) scrape(ch chan<- prometheus.Metric) { e.up.Set(1) e.totalScrapes.Inc() if time.Now().Sub(tempUpdated) < staleInterval { ch <- prometheus.MustNewConstMetric( prometheus.NewDesc(prometheus.BuildFQName(namespace, "sensor", "temperature"), "Current temperature.", []string{"metric"}, nil), prometheus.GaugeValue, celsius, "celsius", ) ch <- prometheus.MustNewConstMetric( prometheus.NewDesc(prometheus.BuildFQName(namespace, "sensor", "temperature"), "Temperature in C and F.", []string{"metric"}, nil), prometheus.GaugeValue, fahrenheit, "fahrenheit", ) } if time.Now().Sub(soundUpdated) < staleInterval { ch <- prometheus.MustNewConstMetric( prometheus.NewDesc(prometheus.BuildFQName(namespace, "sensor", "sound"), "Sound (noise) level.", nil, nil), prometheus.GaugeValue, float64(sound), ) } if time.Now().Sub(lightUpdated) < staleInterval { ch <- prometheus.MustNewConstMetric( prometheus.NewDesc(prometheus.BuildFQName(namespace, "sensor", "light"), "Luminous flux per unit area.", nil, nil), prometheus.GaugeValue, float64(light), ) } }
// Takes a prometheus registry and returns a new Collector exposing // kernel/system statistics. func NewPfCollector() (Collector, error) { subsystem := "pf" return &pfCollector{ match: prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "match"), "PF internal Match counter.", nil, nil, ), states: prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "state_count"), "State Table entry count.", nil, nil, ), searches: prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "state_search"), "State Table search counter.", nil, nil, ), inserts: prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "state_insert"), "State Table insert counter.", nil, nil, ), removals: prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "state_removal"), "State Table remove counter.", nil, nil, ), }, nil }
// Takes a prometheus registry and returns a new Collector exposing // Device stats. func NewDevstatCollector() (Collector, error) { return &devstatCollector{ devinfo: &C.struct_devinfo{}, bytes: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, devstatSubsystem, "bytes_total"), "The total number of bytes in transactions.", []string{"device", "type"}, nil, ), prometheus.CounterValue}, transfers: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, devstatSubsystem, "transfers_total"), "The total number of transactions.", []string{"device", "type"}, nil, ), prometheus.CounterValue}, duration: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, devstatSubsystem, "duration_seconds_total"), "The total duration of transactions in seconds.", []string{"device", "type"}, nil, ), prometheus.CounterValue}, busyTime: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, devstatSubsystem, "busy_time_seconds_total"), "Total time the device had one or more transactions outstanding in seconds.", []string{"device"}, nil, ), prometheus.CounterValue}, blocks: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, devstatSubsystem, "blocks_transferred_total"), "The total number of blocks transferred.", []string{"device"}, nil, ), prometheus.CounterValue}, }, nil }
func NewRunitCollector() (Collector, error) { var ( subsystem = "service" constLabels = prometheus.Labels{"supervisor": "runit"} labelNames = []string{"service"} ) return &runitCollector{ state: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "state"), "State of runit service.", labelNames, constLabels, ), prometheus.GaugeValue}, stateDesired: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "desired_state"), "Desired state of runit service.", labelNames, constLabels, ), prometheus.GaugeValue}, stateNormal: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "normal_state"), "Normal state of runit service.", labelNames, constLabels, ), prometheus.GaugeValue}, stateTimestamp: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "state_last_change_timestamp_seconds"), "Unix timestamp of the last runit service state change.", labelNames, constLabels, ), prometheus.GaugeValue}, }, nil }
func NewExporter(uri string) *Exporter { return &Exporter{ URI: uri, up: prometheus.NewDesc( prometheus.BuildFQName(namespace, "", "up"), "Could the apache server be reached", nil, nil), scrapeFailures: prometheus.NewCounter(prometheus.CounterOpts{ Namespace: namespace, Name: "exporter_scrape_failures_total", Help: "Number of errors while scraping apache.", }), accessesTotal: prometheus.NewDesc( prometheus.BuildFQName(namespace, "", "accesses_total"), "Current total apache accesses", nil, nil), kBytesTotal: prometheus.NewDesc( prometheus.BuildFQName(namespace, "", "sent_kilobytes_total"), "Current total kbytes sent", nil, nil), uptime: prometheus.NewDesc( prometheus.BuildFQName(namespace, "", "uptime_seconds_total"), "Current uptime in seconds", nil, nil), workers: prometheus.NewGaugeVec(prometheus.GaugeOpts{ Namespace: namespace, Name: "workers", Help: "Apache worker statuses", }, []string{"state"}, ), scoreboard: prometheus.NewGaugeVec(prometheus.GaugeOpts{ Namespace: namespace, Name: "scoreboard", Help: "Apache scoreboard statuses", }, []string{"state"}, ), connections: prometheus.NewGaugeVec(prometheus.GaugeOpts{ Namespace: namespace, Name: "connections", Help: "Apache connection statuses", }, []string{"state"}, ), client: &http.Client{ Transport: &http.Transport{ TLSClientConfig: &tls.Config{InsecureSkipVerify: *insecure}, }, }, } }
// NewBondingCollector returns a newly allocated bondingCollector. // It exposes the number of configured and active slave of linux bonding interfaces. func NewBondingCollector() (Collector, error) { return &bondingCollector{ slaves: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, "bonding", "slaves"), "Number of configured slaves per bonding interface.", []string{"master"}, nil, ), prometheus.GaugeValue}, active: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, "bonding", "active"), "Number of active slaves per bonding interface.", []string{"master"}, nil, ), prometheus.GaugeValue}, }, nil }
// Takes a prometheus registry and returns a new Collector exposing // conntrack stats func NewConntrackCollector() (Collector, error) { return &conntrackCollector{ current: prometheus.NewDesc( prometheus.BuildFQName(Namespace, "", "nf_conntrack_entries"), "Number of currently allocated flow entries for connection tracking.", nil, nil, ), limit: prometheus.NewDesc( prometheus.BuildFQName(Namespace, "", "nf_conntrack_entries_limit"), "Maximum size of connection tracking table.", nil, nil, ), }, nil }
// Takes a prometheus registry and returns a new Collector exposing // CPU stats. func NewStatCollector() (Collector, error) { return &statCollector{ cpu: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, "cpu", "seconds_total"), "Seconds the CPU spent in each mode.", []string{"cpu", "mode"}, nil, ), prometheus.CounterValue}, temp: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, "cpu", "temperature_celsius"), "CPU temperature", []string{"cpu"}, nil, ), prometheus.GaugeValue}, }, nil }
func (m *Metric) PromDescription(exporterName string) *prometheus.Desc { return prometheus.NewDesc( prometheus.BuildFQName("", exporterName, m.Name), m.Description, m.LabelKeys, nil, ) }
func (c *netStatCollector) Update(ch chan<- prometheus.Metric) (err error) { netStats, err := getNetStats(procFilePath("net/netstat")) if err != nil { return fmt.Errorf("couldn't get netstats: %s", err) } snmpStats, err := getNetStats(procFilePath("net/snmp")) if err != nil { return fmt.Errorf("couldn't get SNMP stats: %s", err) } // Merge the results of snmpStats into netStats (collisions are possible, but // we know that the keys are always unique for the given use case). for k, v := range snmpStats { netStats[k] = v } for protocol, protocolStats := range netStats { for name, value := range protocolStats { key := protocol + "_" + name v, err := strconv.ParseFloat(value, 64) if err != nil { return fmt.Errorf("invalid value %s in netstats: %s", value, err) } ch <- prometheus.MustNewConstMetric( prometheus.NewDesc( prometheus.BuildFQName(Namespace, netStatsSubsystem, key), fmt.Sprintf("Protocol %s statistic %s.", protocol, name), nil, nil, ), prometheus.UntypedValue, v, ) } } return nil }
func (c *netDevCollector) Update(ch chan<- prometheus.Metric) (err error) { netDev, err := getNetDevStats(c.ignoredDevicesPattern) if err != nil { return fmt.Errorf("couldn't get netstats: %s", err) } for dev, devStats := range netDev { for key, value := range devStats { desc, ok := c.metricDescs[key] if !ok { desc = prometheus.NewDesc( prometheus.BuildFQName(Namespace, c.subsystem, key), fmt.Sprintf("Network device statistic %s.", key), []string{"device"}, nil, ) c.metricDescs[key] = desc } v, err := strconv.ParseFloat(value, 64) if err != nil { return fmt.Errorf("invalid value %s in netstats: %s", value, err) } ch <- prometheus.MustNewConstMetric(desc, prometheus.GaugeValue, v, dev) } } return nil }
func (c *vmStatCollector) Update(ch chan<- prometheus.Metric) (err error) { file, err := os.Open(procFilePath("vmstat")) if err != nil { return err } defer file.Close() scanner := bufio.NewScanner(file) for scanner.Scan() { parts := strings.Fields(scanner.Text()) value, err := strconv.ParseFloat(parts[1], 64) if err != nil { return err } ch <- prometheus.MustNewConstMetric( prometheus.NewDesc( prometheus.BuildFQName(Namespace, vmStatSubsystem, parts[0]), fmt.Sprintf("/proc/vmstat information field %s.", parts[0]), nil, nil), prometheus.UntypedValue, value, ) } return err }
// ScrapeClientStat collects from `information_schema.client_statistics`. func ScrapeClientStat(db *sql.DB, ch chan<- prometheus.Metric) error { var varName, varVal string err := db.QueryRow(userstatCheckQuery).Scan(&varName, &varVal) if err != nil { log.Debugln("Detailed client stats are not available.") return nil } if varVal == "OFF" { log.Debugf("MySQL @@%s is OFF.", varName) return nil } informationSchemaClientStatisticsRows, err := db.Query(clientStatQuery) if err != nil { return err } defer informationSchemaClientStatisticsRows.Close() // The client column is assumed to be column[0], while all other data is assumed to be coerceable to float64. // Because of the client column, clientStatData[0] maps to columnNames[1] when reading off the metrics // (because clientStatScanArgs is mapped as [ &client, &clientData[0], &clientData[1] ... &clientdata[n] ] // To map metrics to names therefore we always range over columnNames[1:] columnNames, err := informationSchemaClientStatisticsRows.Columns() if err != nil { return err } var ( client string // Holds the client name, which should be in column 0. clientStatData = make([]float64, len(columnNames)-1) // 1 less because of the client column. clientStatScanArgs = make([]interface{}, len(columnNames)) ) clientStatScanArgs[0] = &client for i := range clientStatData { clientStatScanArgs[i+1] = &clientStatData[i] } for informationSchemaClientStatisticsRows.Next() { if err := informationSchemaClientStatisticsRows.Scan(clientStatScanArgs...); err != nil { return err } // Loop over column names, and match to scan data. Unknown columns // will be filled with an untyped metric number. We assume other then // cient, that we'll only get numbers. for idx, columnName := range columnNames[1:] { if metricType, ok := informationSchemaClientStatisticsTypes[columnName]; ok { ch <- prometheus.MustNewConstMetric(metricType.desc, metricType.vtype, float64(clientStatData[idx]), client) } else { // Unknown metric. Report as untyped. desc := prometheus.NewDesc(prometheus.BuildFQName(namespace, informationSchema, fmt.Sprintf("client_statistics_%s", strings.ToLower(columnName))), fmt.Sprintf("Unsupported metric from column %s", columnName), []string{"client"}, nil) ch <- prometheus.MustNewConstMetric(desc, prometheus.UntypedValue, float64(clientStatData[idx]), client) } } } return nil }
// NewMemStatCollector is a method which return new lxc memory collector func NewMemStatCollector() Collector { return &lxcMemCollector{ memory: prometheus.NewDesc( prometheus.BuildFQName(Namespace, "", "memory_usage"), "Memory usage in each container in bytes.", []string{"container"}, nil, ), } }
// ScrapeSlaveStatus collects from `SHOW SLAVE STATUS`. func ScrapeSlaveStatus(db *sql.DB, ch chan<- prometheus.Metric) error { var ( slaveStatusRows *sql.Rows err error ) // Leverage lock-free SHOW SLAVE STATUS by guessing the right suffix for _, suffix := range slaveStatusQuerySuffixes { slaveStatusRows, err = db.Query(fmt.Sprint(slaveStatusQuery, suffix)) if err == nil { break } } if err != nil { return err } defer slaveStatusRows.Close() slaveCols, err := slaveStatusRows.Columns() if err != nil { return err } for slaveStatusRows.Next() { // As the number of columns varies with mysqld versions, // and sql.Scan requires []interface{}, we need to create a // slice of pointers to the elements of slaveData. scanArgs := make([]interface{}, len(slaveCols)) for i := range scanArgs { scanArgs[i] = &sql.RawBytes{} } if err := slaveStatusRows.Scan(scanArgs...); err != nil { return err } masterUUID := columnValue(scanArgs, slaveCols, "Master_UUID") masterHost := columnValue(scanArgs, slaveCols, "Master_Host") channelName := columnValue(scanArgs, slaveCols, "Channel_Name") for i, col := range slaveCols { if value, ok := parseStatus(*scanArgs[i].(*sql.RawBytes)); ok { // Silently skip unparsable values. ch <- prometheus.MustNewConstMetric( prometheus.NewDesc( prometheus.BuildFQName(namespace, slaveStatus, strings.ToLower(col)), "Generic metric from SHOW SLAVE STATUS.", []string{"master_uuid", "master_host", "channel_name"}, nil, ), prometheus.UntypedValue, value, masterUUID, masterHost, channelName, ) } } } return nil }
// NewTCPStatCollector takes a returns // a new Collector exposing network stats. func NewTCPStatCollector() (Collector, error) { return &tcpStatCollector{ desc: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, "tcp", "connection_states"), "Number of connection states.", []string{"state"}, nil, ), prometheus.GaugeValue}, }, nil }
// Takes a prometheus registry and returns a new Collector exposing // entropy stats func NewEntropyCollector() (Collector, error) { return &entropyCollector{ entropy_avail: prometheus.NewDesc( prometheus.BuildFQName(Namespace, "", "entropy_available_bits"), "Bits of available entropy.", nil, nil, ), }, nil }
// Takes a prometheus registry and returns a new Collector exposing // systemd statistics. func NewSystemdCollector() (Collector, error) { const subsystem = "systemd" unitDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "unit_state"), "Systemd unit", []string{"name", "state"}, nil, ) systemRunningDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "system_running"), "Whether the system is operational (see 'systemctl is-system-running')", nil, nil, ) return &systemdCollector{ unitDesc: unitDesc, systemRunningDesc: systemRunningDesc, }, nil }
func newDRBDStringPairMetric(name string, desc string, valueOkay string) drbdStringPairMetric { return drbdStringPairMetric{ desc: prometheus.NewDesc( prometheus.BuildFQName(Namespace, "drbd", name), desc, []string{"device", "node"}, nil), valueOkay: valueOkay, } }
// 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), ), } }
// Takes a prometheus registry and returns a new Collector exposing // CPU stats. func NewCPUCollector() (Collector, error) { return &statCollector{ cpu: prometheus.NewDesc( prometheus.BuildFQName(Namespace, "", "cpu"), "Seconds the cpus spent in each mode.", []string{"cpu", "mode"}, nil, ), }, nil }
// Takes a prometheus registry and returns a new Collector exposing // Filesystems stats. func NewFilesystemCollector() (Collector, error) { subsystem := "filesystem" mountPointPattern := regexp.MustCompile(*ignoredMountPoints) filesystemsTypesPattern := regexp.MustCompile(*ignoredFSTypes) sizeDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "size"), "Filesystem size in bytes.", filesystemLabelNames, nil, ) freeDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "free"), "Filesystem free space in bytes.", filesystemLabelNames, nil, ) availDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "avail"), "Filesystem space available to non-root users in bytes.", filesystemLabelNames, nil, ) filesDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "files"), "Filesystem total file nodes.", filesystemLabelNames, nil, ) filesFreeDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "files_free"), "Filesystem total free file nodes.", filesystemLabelNames, nil, ) roDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "readonly"), "Filesystem read-only status.", filesystemLabelNames, nil, ) devErrors := prometheus.NewCounterVec(prometheus.CounterOpts{ Name: prometheus.BuildFQName(Namespace, subsystem, "device_errors_total"), Help: "Total number of errors occurred when getting stats for device", }, filesystemLabelNames) return &filesystemCollector{ ignoredMountPointsPattern: mountPointPattern, ignoredFSTypesPattern: filesystemsTypesPattern, sizeDesc: sizeDesc, freeDesc: freeDesc, availDesc: availDesc, filesDesc: filesDesc, filesFreeDesc: filesFreeDesc, roDesc: roDesc, devErrors: devErrors, }, nil }
// Takes a prometheus registry and returns a new Collector exposing // Filesystems stats. func NewFilesystemCollector() (Collector, error) { subsystem := "filesystem" pattern := regexp.MustCompile(*ignoredMountPoints) sizeDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "size"), "Filesystem size in bytes.", filesystemLabelNames, nil, ) freeDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "free"), "Filesystem free space in bytes.", filesystemLabelNames, nil, ) availDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "avail"), "Filesystem space available to non-root users in bytes.", filesystemLabelNames, nil, ) filesDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "files"), "Filesystem total file nodes.", filesystemLabelNames, nil, ) filesFreeDesc := prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, "files_free"), "Filesystem total free file nodes.", filesystemLabelNames, nil, ) return &filesystemCollector{ ignoredMountPointsPattern: pattern, sizeDesc: sizeDesc, freeDesc: freeDesc, availDesc: availDesc, filesDesc: filesDesc, filesFreeDesc: filesFreeDesc, }, nil }
func newDRBDNumericalMetric(name string, desc string, valueType prometheus.ValueType, multiplier float64) drbdNumericalMetric { return drbdNumericalMetric{ desc: prometheus.NewDesc( prometheus.BuildFQName(Namespace, "drbd", name), desc, []string{"device"}, nil), valueType: valueType, multiplier: multiplier, } }
// Takes a prometheus registry and returns a new Collector exposing // Device stats. func NewDevstatCollector() (Collector, error) { return &devstatCollector{ bytesDesc: prometheus.NewDesc( prometheus.BuildFQName(Namespace, devstatSubsystem, "bytes_total"), "The total number of bytes transferred for reads and writes on the device.", []string{"device"}, nil, ), transfersDesc: prometheus.NewDesc( prometheus.BuildFQName(Namespace, devstatSubsystem, "transfers_total"), "The total number of transactions completed.", []string{"device"}, nil, ), blocksDesc: prometheus.NewDesc( prometheus.BuildFQName(Namespace, devstatSubsystem, "blocks_total"), "The total number of bytes given in terms of the devices blocksize.", []string{"device"}, nil, ), }, nil }
func newSettableCounter(subsystem, name, help string) *settableCounter { return &settableCounter{ desc: prometheus.NewDesc( prometheus.BuildFQName("mesos", subsystem, name), help, nil, prometheus.Labels{}, ), } }
// Takes a prometheus registry and returns a new Collector exposing // kernel/system statistics. func NewKsmdCollector() (Collector, error) { subsystem := "ksmd" descs := make(map[string]*prometheus.Desc) for _, n := range ksmdFiles { descs[n] = prometheus.NewDesc( prometheus.BuildFQName(Namespace, subsystem, getCanonicalMetricName(n)), fmt.Sprintf("ksmd '%s' file.", n), nil, nil) } return &ksmdCollector{descs}, nil }
// NewStorageQueueManager builds a new StorageQueueManager. func NewStorageQueueManager(tsdb StorageClient, queueCapacity int) *StorageQueueManager { constLabels := prometheus.Labels{ "type": tsdb.Name(), } return &StorageQueueManager{ tsdb: tsdb, queue: make(chan *clientmodel.Sample, queueCapacity), sendSemaphore: make(chan bool, maxConcurrentSends), drained: make(chan bool), samplesCount: prometheus.NewCounterVec( prometheus.CounterOpts{ Namespace: namespace, Subsystem: subsystem, Name: "sent_samples_total", Help: "Total number of processed samples to be sent to remote storage.", ConstLabels: constLabels, }, []string{result}, ), sendLatency: prometheus.NewSummary(prometheus.SummaryOpts{ Namespace: namespace, Subsystem: subsystem, Name: "sent_latency_milliseconds", Help: "Latency quantiles for sending sample batches to the remote storage.", ConstLabels: constLabels, }), sendErrors: prometheus.NewCounter(prometheus.CounterOpts{ Namespace: namespace, Subsystem: subsystem, Name: "sent_errors_total", Help: "Total number of errors sending sample batches to the remote storage.", ConstLabels: constLabels, }), queueLength: prometheus.NewGauge(prometheus.GaugeOpts{ Namespace: namespace, Subsystem: subsystem, Name: "queue_length", Help: "The number of processed samples queued to be sent to the remote storage.", ConstLabels: constLabels, }), queueCapacity: prometheus.MustNewConstMetric( prometheus.NewDesc( prometheus.BuildFQName(namespace, subsystem, "queue_capacity"), "The capacity of the queue of samples to be sent to the remote storage.", nil, constLabels, ), prometheus.GaugeValue, float64(queueCapacity), ), } }
func newHistogramCollector(opts prometheus.Opts, h *stats.Histogram) histogramCollector { desc := prometheus.NewDesc( prometheus.BuildFQName(opts.Namespace, opts.Subsystem, opts.Name), opts.Help, nil, opts.ConstLabels, ) return histogramCollector{ desc: desc, h: h, } }
// Takes a prometheus registry and returns a new Collector exposing // the offset between ntp and the current system time. func NewNtpCollector() (Collector, error) { warnDeprecated("ntp") if *ntpServer == "" { return nil, fmt.Errorf("no NTP server specified, see -collector.ntp.server") } if *ntpProtocolVersion < 2 || *ntpProtocolVersion > 4 { return nil, fmt.Errorf("invalid NTP protocol version %d; must be 2, 3, or 4", *ntpProtocolVersion) } return &ntpCollector{ drift: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, "ntp", "drift_seconds"), "Time between system time and ntp time.", nil, nil, ), prometheus.GaugeValue}, stratum: typedDesc{prometheus.NewDesc( prometheus.BuildFQName(Namespace, "ntp", "stratum"), "NTP server stratum.", nil, nil, ), prometheus.GaugeValue}, }, nil }