mirror of
https://github.com/prometheus-community/windows_exporter.git
synced 2026-10-17 18:19:04 +02:00
447 lines
11 KiB
Go
447 lines
11 KiB
Go
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
// Copyright The Prometheus Authors
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
//go:build windows
|
|
|
|
package textfile
|
|
|
|
import (
|
|
"bufio"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"maps"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/alecthomas/kingpin/v2"
|
|
"github.com/prometheus-community/windows_exporter/internal/mi"
|
|
"github.com/prometheus-community/windows_exporter/internal/types"
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
dto "github.com/prometheus/client_model/go"
|
|
"github.com/prometheus/common/expfmt"
|
|
"github.com/prometheus/common/model"
|
|
)
|
|
|
|
const Name = "textfile"
|
|
|
|
type Config struct {
|
|
TextFileDirectories []string `yaml:"directories"`
|
|
}
|
|
|
|
//nolint:gochecknoglobals
|
|
var ConfigDefaults = Config{
|
|
TextFileDirectories: []string{getDefaultPath()},
|
|
}
|
|
|
|
type Collector struct {
|
|
config Config
|
|
logger *slog.Logger
|
|
|
|
// Only set for testing to get predictable output.
|
|
mTime *float64
|
|
|
|
modTimeDesc *prometheus.Desc
|
|
}
|
|
|
|
func New(config *Config) *Collector {
|
|
if config == nil {
|
|
config = &ConfigDefaults
|
|
}
|
|
|
|
if config.TextFileDirectories == nil {
|
|
config.TextFileDirectories = ConfigDefaults.TextFileDirectories
|
|
}
|
|
|
|
c := &Collector{
|
|
config: *config,
|
|
}
|
|
|
|
return c
|
|
}
|
|
|
|
func NewWithFlags(app *kingpin.Application) *Collector {
|
|
c := &Collector{
|
|
config: ConfigDefaults,
|
|
}
|
|
|
|
var textFileDirectories string
|
|
|
|
app.Flag(
|
|
"collector.textfile.directories",
|
|
"Directory or Directories to read text files with metrics from.",
|
|
).Default(strings.Join(ConfigDefaults.TextFileDirectories, ",")).StringVar(&textFileDirectories)
|
|
|
|
app.Action(func(*kingpin.ParseContext) error {
|
|
c.config.TextFileDirectories = strings.Split(textFileDirectories, ",")
|
|
|
|
return nil
|
|
})
|
|
|
|
return c
|
|
}
|
|
|
|
func (c *Collector) GetName() string {
|
|
return Name
|
|
}
|
|
|
|
func (c *Collector) Close() error {
|
|
return nil
|
|
}
|
|
|
|
func (c *Collector) Build(logger *slog.Logger, _ *mi.Session) error {
|
|
c.logger = logger.With(slog.String("collector", Name))
|
|
|
|
c.logger.Info("textfile directories: " + strings.Join(c.config.TextFileDirectories, ","))
|
|
|
|
c.modTimeDesc = prometheus.NewDesc(
|
|
prometheus.BuildFQName(types.Namespace, "textfile", "mtime_seconds"),
|
|
"Unixtime mtime of textfiles successfully read.",
|
|
[]string{"file"},
|
|
nil,
|
|
)
|
|
|
|
return nil
|
|
}
|
|
|
|
// Given a slice of metric families, determine if any two entries are duplicates.
|
|
// Duplicates will be detected where the metric name, labels and label values are identical.
|
|
// Labels with an empty value are ignored, because convertMetricFamily adds missing labels
|
|
// with an empty value, and Prometheus treats them as absent.
|
|
func duplicateMetricEntry(metricFamilies []*dto.MetricFamily) bool {
|
|
seen := make(map[string]struct{})
|
|
|
|
for _, metricFamily := range metricFamilies {
|
|
for _, metric := range metricFamily.GetMetric() {
|
|
key := seriesKey(metricFamily.GetName(), metric.GetLabel())
|
|
|
|
if _, ok := seen[key]; ok {
|
|
return true
|
|
}
|
|
|
|
seen[key] = struct{}{}
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// seriesKey returns a key that identifies a series by its metric name and its non-empty labels,
|
|
// independent of the label order.
|
|
func seriesKey(metricName string, labelPairs []*dto.LabelPair) string {
|
|
labels := make(map[string]string, len(labelPairs))
|
|
|
|
for _, label := range labelPairs {
|
|
if label.GetValue() != "" {
|
|
labels[label.GetName()] = label.GetValue()
|
|
}
|
|
}
|
|
|
|
var sb strings.Builder
|
|
|
|
sb.WriteString(metricName)
|
|
|
|
// The separator byte is not valid UTF-8, so it can't be part of a label name or value.
|
|
for _, name := range slices.Sorted(maps.Keys(labels)) {
|
|
sb.WriteByte(model.SeparatorByte)
|
|
sb.WriteString(name)
|
|
sb.WriteByte(model.SeparatorByte)
|
|
sb.WriteString(labels[name])
|
|
}
|
|
|
|
return sb.String()
|
|
}
|
|
|
|
func (c *Collector) convertMetricFamily(logger *slog.Logger, metricFamily *dto.MetricFamily, ch chan<- prometheus.Metric) {
|
|
var valType prometheus.ValueType
|
|
|
|
var val float64
|
|
|
|
allLabelNames := map[string]struct{}{}
|
|
|
|
for _, metric := range metricFamily.GetMetric() {
|
|
labels := metric.GetLabel()
|
|
for _, label := range labels {
|
|
if _, ok := allLabelNames[label.GetName()]; !ok {
|
|
allLabelNames[label.GetName()] = struct{}{}
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, metric := range metricFamily.GetMetric() {
|
|
if metric.TimestampMs != nil {
|
|
logger.Warn(fmt.Sprintf("Ignoring unsupported custom timestamp on textfile metric %v", metric))
|
|
}
|
|
|
|
labels := metric.GetLabel()
|
|
|
|
var names []string
|
|
|
|
var values []string
|
|
|
|
for _, label := range labels {
|
|
names = append(names, label.GetName())
|
|
values = append(values, label.GetValue())
|
|
}
|
|
|
|
for k := range allLabelNames {
|
|
if !slices.Contains(names, k) {
|
|
names = append(names, k)
|
|
values = append(values, "")
|
|
}
|
|
}
|
|
|
|
metricType := metricFamily.GetType()
|
|
switch metricType {
|
|
case dto.MetricType_COUNTER:
|
|
valType = prometheus.CounterValue
|
|
val = metric.GetCounter().GetValue()
|
|
|
|
case dto.MetricType_GAUGE:
|
|
valType = prometheus.GaugeValue
|
|
val = metric.GetGauge().GetValue()
|
|
|
|
case dto.MetricType_UNTYPED:
|
|
valType = prometheus.UntypedValue
|
|
val = metric.GetUntyped().GetValue()
|
|
|
|
case dto.MetricType_SUMMARY:
|
|
quantiles := map[float64]float64{}
|
|
for _, q := range metric.GetSummary().GetQuantile() {
|
|
quantiles[q.GetQuantile()] = q.GetValue()
|
|
}
|
|
|
|
ch <- prometheus.MustNewConstSummary(
|
|
prometheus.NewDesc(
|
|
metricFamily.GetName(),
|
|
metricFamily.GetHelp(),
|
|
names, nil,
|
|
),
|
|
metric.GetSummary().GetSampleCount(),
|
|
metric.GetSummary().GetSampleSum(),
|
|
quantiles, values...,
|
|
)
|
|
case dto.MetricType_HISTOGRAM:
|
|
buckets := map[float64]uint64{}
|
|
for _, b := range metric.GetHistogram().GetBucket() {
|
|
buckets[b.GetUpperBound()] = b.GetCumulativeCount()
|
|
}
|
|
|
|
ch <- prometheus.MustNewConstHistogram(
|
|
prometheus.NewDesc(
|
|
metricFamily.GetName(),
|
|
metricFamily.GetHelp(),
|
|
names, nil,
|
|
),
|
|
metric.GetHistogram().GetSampleCount(),
|
|
metric.GetHistogram().GetSampleSum(),
|
|
buckets, values...,
|
|
)
|
|
default:
|
|
logger.Error("unknown metric type for file")
|
|
|
|
continue
|
|
}
|
|
|
|
if metricType == dto.MetricType_GAUGE || metricType == dto.MetricType_COUNTER || metricType == dto.MetricType_UNTYPED {
|
|
ch <- prometheus.MustNewConstMetric(
|
|
prometheus.NewDesc(
|
|
metricFamily.GetName(),
|
|
metricFamily.GetHelp(),
|
|
names, nil,
|
|
),
|
|
valType, val, values...,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *Collector) exportMTimes(modTimes map[string]time.Time, ch chan<- prometheus.Metric) {
|
|
// Export the mtimes of the successful files.
|
|
if len(modTimes) > 0 {
|
|
// Sorting is needed for predictable output comparison in tests.
|
|
filenames := make([]string, 0, len(modTimes))
|
|
for filename := range modTimes {
|
|
filenames = append(filenames, filename)
|
|
}
|
|
|
|
sort.Strings(filenames)
|
|
|
|
for _, filename := range filenames {
|
|
modTime := float64(modTimes[filename].UnixNano() / 1e9)
|
|
if c.mTime != nil {
|
|
modTime = *c.mTime
|
|
}
|
|
|
|
ch <- prometheus.MustNewConstMetric(c.modTimeDesc, prometheus.GaugeValue, modTime, filename)
|
|
}
|
|
}
|
|
}
|
|
|
|
type carriageReturnFilteringReader struct {
|
|
r io.Reader
|
|
}
|
|
|
|
// Read returns data from the underlying io.Reader, but with \r filtered out.
|
|
func (cr carriageReturnFilteringReader) Read(p []byte) (int, error) {
|
|
buf := make([]byte, len(p))
|
|
|
|
n, err := cr.r.Read(buf)
|
|
if err != nil && err != io.EOF {
|
|
return n, err
|
|
}
|
|
|
|
pi := 0
|
|
|
|
for i := range n {
|
|
if buf[i] != '\r' {
|
|
p[pi] = buf[i]
|
|
pi++
|
|
}
|
|
}
|
|
|
|
return pi, err
|
|
}
|
|
|
|
// Collect implements the Collector interface.
|
|
func (c *Collector) Collect(ch chan<- prometheus.Metric, _ time.Duration) error {
|
|
mTimes := map[string]time.Time{}
|
|
|
|
// Create empty metricFamily slice here and append parsedFamilies to it inside the loop.
|
|
// Once loop is complete, raise error if any duplicates are present.
|
|
// This will ensure that duplicate metrics are correctly detected between multiple .prom files.
|
|
var metricFamilies []*dto.MetricFamily
|
|
|
|
errs := make([]error, 0)
|
|
|
|
// Iterate over files and accumulate their metrics.
|
|
for _, directory := range c.config.TextFileDirectories {
|
|
err := filepath.WalkDir(directory, func(path string, dirEntry os.DirEntry, err error) error {
|
|
if err != nil {
|
|
return fmt.Errorf("error reading directory: %w", err)
|
|
}
|
|
|
|
if !dirEntry.IsDir() && strings.HasSuffix(dirEntry.Name(), ".prom") {
|
|
c.logger.Debug("Processing file: " + path)
|
|
|
|
families_array, err := scrapeFile(path, c.logger)
|
|
if err != nil {
|
|
errs = append(errs, fmt.Errorf("error scraping file %q: %w", path, err))
|
|
|
|
return nil
|
|
}
|
|
|
|
fileInfo, err := os.Stat(path)
|
|
if err != nil {
|
|
errs = append(errs, fmt.Errorf("error reading file info %q: %w", path, err))
|
|
|
|
return nil
|
|
}
|
|
|
|
if _, hasName := mTimes[fileInfo.Name()]; hasName {
|
|
errs = append(errs, fmt.Errorf("duplicate filename detected: %q", path))
|
|
|
|
return nil
|
|
}
|
|
|
|
mTimes[fileInfo.Name()] = fileInfo.ModTime()
|
|
|
|
metricFamilies = append(metricFamilies, families_array...)
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil && directory != "" {
|
|
errs = append(errs, fmt.Errorf("error reading textfile directory %q: %w", directory, err))
|
|
}
|
|
}
|
|
|
|
c.exportMTimes(mTimes, ch)
|
|
|
|
// If duplicates are detected across *multiple* files, return error.
|
|
if duplicateMetricEntry(metricFamilies) {
|
|
c.logger.Warn("duplicate metrics detected across multiple files")
|
|
} else {
|
|
for _, mf := range metricFamilies {
|
|
c.convertMetricFamily(c.logger, mf, ch)
|
|
}
|
|
}
|
|
|
|
return errors.Join(errs...)
|
|
}
|
|
|
|
func scrapeFile(path string, logger *slog.Logger) ([]*dto.MetricFamily, error) {
|
|
file, err := os.Open(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
defer func() {
|
|
if err := file.Close(); err != nil {
|
|
logger.Warn("error closing file "+path,
|
|
slog.Any("err", err),
|
|
)
|
|
}
|
|
}()
|
|
|
|
parser := expfmt.NewTextParser(model.UTF8Validation)
|
|
|
|
r := bufio.NewReader(carriageReturnFilteringReader{r: file})
|
|
if err := skipUTF8BOM(r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
parsedFamilies, err := parser.TextToMetricFamilies(r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Use temporary array to check for duplicates
|
|
families_array := make([]*dto.MetricFamily, 0, len(parsedFamilies))
|
|
|
|
for _, mf := range parsedFamilies {
|
|
families_array = append(families_array, mf)
|
|
|
|
for _, m := range mf.GetMetric() {
|
|
if m.TimestampMs != nil {
|
|
return nil, errors.New("textfile contains unsupported client-side timestamps")
|
|
}
|
|
}
|
|
|
|
if mf.Help == nil {
|
|
help := "Metric read from textfile collector"
|
|
mf.Help = &help
|
|
}
|
|
}
|
|
|
|
// If duplicate metrics are detected in a *single* file, skip processing of file metrics
|
|
if duplicateMetricEntry(families_array) {
|
|
return nil, errors.New("duplicate metrics detected")
|
|
}
|
|
|
|
return families_array, nil
|
|
}
|
|
|
|
func getDefaultPath() string {
|
|
execPath, _ := os.Executable()
|
|
|
|
return filepath.Join(filepath.Dir(execPath), "textfile_inputs")
|
|
}
|