metric.go

package main

import (
	"bytes"
	"context"
	"crypto/sha256"
	"database/sql"
	"errors"
	"fmt"
	"hash"
	"io"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/BurntSushi/toml"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/sirupsen/logrus"
)

// Metrics to scrap. Use external file (default-metrics.toml and custom if provided)
var (
	metricsLock    *sync.RWMutex = new(sync.RWMutex)
	metricsToScrap Metrics
	hashMap        map[string][]byte = make(map[string][]byte)
)

// Metrics object description
type Metric struct {
	Context          string
	Labels           []string
	MetricsDesc      map[string]string
	MetricsType      map[string]string
	MetricsBuckets   map[string]map[string]string
	FieldToAppend    string
	Request          string
	IgnoreZeroResult bool
}

// Used to load multiple metrics from file
type Metrics struct {
	Metric []Metric
}

func GetMetricType(metricType string, metricsType map[string]string) (prometheus.ValueType, error) {
	var strToPromType = map[string]prometheus.ValueType{
		"gauge":     prometheus.GaugeValue,
		"counter":   prometheus.CounterValue,
		"histogram": prometheus.UntypedValue,
	}

	strType, ok := metricsType[strings.ToLower(metricType)]
	if !ok {
		return prometheus.GaugeValue, nil
	}
	valueType, ok := strToPromType[strings.ToLower(strType)]
	if !ok {
		return 0, errors.New("error while getting prometheus type: " + strings.ToLower(strType))
	}
	return valueType, nil
}

// interface method to call ScrapeGenericValues using Metric struct values
func ScrapeMetric(db *sql.DB, ch chan<- prometheus.Metric, metricDefinition Metric, logger *logrus.Logger) error {
	logger.Debug("Calling function ScrapeGenericValues()")
	return ScrapeGenericValues(db, ch, metricDefinition.Context, metricDefinition.Labels,
		metricDefinition.MetricsDesc, metricDefinition.MetricsType, metricDefinition.MetricsBuckets,
		metricDefinition.FieldToAppend, metricDefinition.IgnoreZeroResult,
		metricDefinition.Request, logger)
}

// generic method for retrieving metrics.
func ScrapeGenericValues(db *sql.DB, ch chan<- prometheus.Metric, context string, labels []string,
	metricsDesc map[string]string, metricsType map[string]string, metricsBuckets map[string]map[string]string, fieldToAppend string, ignoreZeroResult bool, request string, logger *logrus.Logger) error {
	metricsCount := 0
	genericParser := func(row map[string]string) error {
		// Construct labels value
		labelsValues := []string{}
		for _, label := range labels {
			labelsValues = append(labelsValues, row[label])
		}
		// Construct Prometheus values to sent back
		for metric, metricHelp := range metricsDesc {
			value, err := strconv.ParseFloat(strings.TrimSpace(row[metric]), 64)
			// If not a float, skip current metric
			if err != nil {
				logger.Error("Unable to convert current value to float (metric=" + metric +
					",metricHelp=" + metricHelp + ",value=<" + row[metric] + ">)")
				continue
			}
			logger.Debug("Query result looks like: ", value)
			// If metric do not use a field content in metric's name
			if strings.Compare(fieldToAppend, "") == 0 {
				desc := prometheus.NewDesc(
					prometheus.BuildFQName(namespace, context, metric),
					metricHelp,
					labels, nil,
				)
				if metricsType[strings.ToLower(metric)] == "histogram" {
					count, err := strconv.ParseUint(strings.TrimSpace(row["count"]), 10, 64)
					if err != nil {
						logger.Error("Unable to convert count value to int (metric=" + metric +
							",metricHelp=" + metricHelp + ",value=<" + row["count"] + ">)")
						continue
					}
					buckets := make(map[float64]uint64)
					for field, le := range metricsBuckets[metric] {
						lelimit, err := strconv.ParseFloat(strings.TrimSpace(le), 64)
						if err != nil {
							logger.Error("Unable to convert bucket limit value to float (metric=" + metric +
								",metricHelp=" + metricHelp + ",bucketlimit=<" + le + ">)")
							continue
						}
						counter, err := strconv.ParseUint(strings.TrimSpace(row[field]), 10, 64)
						if err != nil {
							logger.Error("Unable to convert ", field, " value to int (metric="+metric+
								",metricHelp="+metricHelp+",value=<"+row[field]+">)")
							continue
						}
						buckets[lelimit] = counter
					}
					ch <- prometheus.MustNewConstHistogram(desc, count, value, buckets, labelsValues...)
				} else {
					vtype, err := GetMetricType(metric, metricsType)
					if err != nil {
						logger.Error(err)
						continue
					}
					ch <- prometheus.MustNewConstMetric(desc, vtype, value, labelsValues...)
				}
				// If no labels, use metric name
			} else {
				desc := prometheus.NewDesc(
					prometheus.BuildFQName(namespace, context, cleanName(row[fieldToAppend])),
					metricHelp,
					nil, nil,
				)
				if metricsType[strings.ToLower(metric)] == "histogram" {
					count, err := strconv.ParseUint(strings.TrimSpace(row["count"]), 10, 64)
					if err != nil {
						logger.Error("Unable to convert count value to int (metric=" + metric +
							",metricHelp=" + metricHelp + ",value=<" + row["count"] + ">)")
						continue
					}
					buckets := make(map[float64]uint64)
					for field, le := range metricsBuckets[metric] {
						lelimit, err := strconv.ParseFloat(strings.TrimSpace(le), 64)
						if err != nil {
							logger.Error("Unable to convert bucket limit value to float (metric=" + metric +
								",metricHelp=" + metricHelp + ",bucketlimit=<" + le + ">)")
							continue
						}
						counter, err := strconv.ParseUint(strings.TrimSpace(row[field]), 10, 64)
						if err != nil {
							logger.Error("Unable to convert ", field, " value to int (metric="+metric+
								",metricHelp="+metricHelp+",value=<"+row[field]+">)")
							continue
						}
						buckets[lelimit] = counter
					}
					ch <- prometheus.MustNewConstHistogram(desc, count, value, buckets)
				} else {
					vtype, err := GetMetricType(metric, metricsType)
					if err != nil {
						logger.Error(err)
						continue
					}
					ch <- prometheus.MustNewConstMetric(desc, vtype, value)
				}
			}
			metricsCount++
		}
		return nil
	}
	logger.Debug("Calling function GeneratePrometheusMetrics()")
	err := GeneratePrometheusMetrics(db, genericParser, request, logger)
	logger.Debug("ScrapeGenericValues() - metricsCount: ", metricsCount)
	if err != nil {
		return err
	}
	if !ignoreZeroResult && metricsCount == 0 {
		return errors.New("no metrics found while parsing")
	}
	return err
}

// inspired by https://kylewbanks.com/blog/query-result-to-map-in-golang
// Parse SQL result and call parsing function to each row
func GeneratePrometheusMetrics(db *sql.DB, parse func(row map[string]string) error, query string, logger *logrus.Logger) error {

	// Add a timeout
	timeout, err := strconv.Atoi(*queryTimeout)
	if err != nil {
		logger.Error("error while converting timeout option value: ", err)
		return err
	}
	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
	defer cancel()
	rows, err := db.QueryContext(ctx, query)

	if ctx.Err() == context.DeadlineExceeded {
		return errors.New("oracle query timed out")
	}

	if err != nil {
		return err
	}
	cols, err := rows.Columns()
	if err != nil {
		return err
	}
	defer rows.Close()

	for rows.Next() {
		// Create a slice of interface{}'s to represent each column,
		// and a second slice to contain pointers to each item in the columns slice.
		columns := make([]interface{}, len(cols))
		columnPointers := make([]interface{}, len(cols))
		for i := range columns {
			columnPointers[i] = &columns[i]
		}

		// Scan the result into the column pointers...
		if err := rows.Scan(columnPointers...); err != nil {
			return err
		}

		// Create our map, and retrieve the value for each column from the pointers slice,
		// storing it in the map with the name of the column as the key.
		m := make(map[string]string)
		for i, colName := range cols {
			val := columnPointers[i].(*interface{})
			m[strings.ToLower(colName)] = fmt.Sprintf("%v", *val)
		}
		// Call function to parse row
		if err := parse(m); err != nil {
			return err
		}
	}

	return nil

}

func checkIfMetricsChanged(logger *logrus.Logger) bool {
	h := sha256.New()
	if err := hashFile(h, *defaultFileMetrics); err != nil {
		logger.Errorf("Unable to hash file [%s], err = %s", *defaultFileMetrics, err)
		return false
	}
	if !bytes.Equal(hashMap[*defaultFileMetrics], h.Sum(nil)) {
		logger.Info(*defaultFileMetrics, " has been changed. Reloading metrics...")
		hashMap[*defaultFileMetrics] = h.Sum(nil)
		return true
	}

	for _, _customMetrics := range strings.Split(*customMetrics, ",") {
		if len(_customMetrics) == 0 {
			continue
		}
		logger.Debug("Checking modifications in following metrics definition file:", _customMetrics)
		h := sha256.New()
		if err := hashFile(h, _customMetrics); err != nil {
			logger.Errorf("Unable to hash file [%s], error = %s", _customMetrics, err)
			return false
		}
		// If any of files has been changed reload metrics
		if !bytes.Equal(hashMap[_customMetrics], h.Sum(nil)) {
			logger.Info(_customMetrics, " has been changed. Reloading metrics...")
			hashMap[_customMetrics] = h.Sum(nil)
			return true
		}
	}
	return false
}

func reloadMetrics(logger *logrus.Logger) {
	var metrics Metrics

	// Truncate metricsToScrap
	// metricsToScrap.Metric = []Metric{}

	// Load default metrics
	if _, err := toml.DecodeFile(*defaultFileMetrics, &metrics); err != nil {
		logger.Errorf("loading [%s] error = %s", *defaultFileMetrics, err)
		return
	} else {
		logger.Info("Successfully loaded default metrics from: " + *defaultFileMetrics)
	}

	h := sha256.New()
	if err := hashFile(h, *defaultFileMetrics); err != nil {
		logger.Errorf("Unable to hash file [%s], err = %s", *defaultFileMetrics, err)
	}
	hashMap[*defaultFileMetrics] = h.Sum(nil)

	// If custom metrics, load it
	if strings.Compare(*customMetrics, "") != 0 {
		for _, _customMetrics := range strings.Split(*customMetrics, ",") {
			if len(_customMetrics) == 0 {
				continue
			}

			h := sha256.New()
			if err := hashFile(h, _customMetrics); err != nil {
				logger.Errorf("Unable to hash file [%s], err = %s", _customMetrics, err)
			}
			hashMap[_customMetrics] = h.Sum(nil)

			var additionalMetrics Metrics
			if _, err := toml.DecodeFile(_customMetrics, &additionalMetrics); err != nil {
				logger.Errorf("loading [%s] error = %s", _customMetrics, err)
				continue
			} else {
				logger.Info("Successfully loaded custom metrics from: " + _customMetrics)
			}
			metrics.Metric = append(metrics.Metric, additionalMetrics.Metric...)
		}
	} else {
		logger.Info("No custom metrics defined.")
	}

	metricsLock.Lock()
	defer metricsLock.Unlock()
	metricsToScrap = metrics
}

// Oracle gives us some ugly names back. This function cleans things up for Prometheus.
func cleanName(s string) string {
	s = strings.Replace(s, " ", "_", -1) // Remove spaces
	s = strings.Replace(s, "(", "", -1)  // Remove open parenthesis
	s = strings.Replace(s, ")", "", -1)  // Remove close parenthesis
	s = strings.Replace(s, "/", "", -1)  // Remove forward slashes
	s = strings.Replace(s, "*", "", -1)  // Remove asterisks
	s = strings.ToLower(s)
	return s
}

func hashFile(h hash.Hash, fn string) error {
	f, err := os.Open(fn)
	if err != nil {
		return err
	}
	defer f.Close()
	if _, err := io.Copy(h, f); err != nil {
		return err
	}
	return nil
}