Merge branch 'public-single-node' into pmm-6401-read-prometheus-data-files

This syncs kubernetes SD with Prometheus 2.25
See 617c56f55a

app/victoria-metrics/main.go

@@ -30,6 +30,12 @@ var (
 		"Unknown config entries are allowed in -promscrape.config by default. This can be changed with -promscrape.config.strictParse")
 )
 
+// custom api help links [["/api","doc"]] without http.pathPrefix.
+var customAPIPathList = [][]string{
+	{"/graph/explore", "explore metrics grafana page"},
+	{"/graph/d/prometheus-advanced/advanced-data-exploration", "PMM grafana dashboard"},
+}
+
 func main() {
 	// Write flags and help message to stdout, since it is easier to grep or pipe.
 	flag.CommandLine.SetOutput(os.Stdout)
@@ -98,6 +104,10 @@ func requestHandler(w http.ResponseWriter, r *http.Request) bool {
 			{"/api/v1/status/top_queries", "top queries"},
 			{"/api/v1/status/active_queries", "active queries"},
 		})
+		for _, p := range customAPIPathList {
+			p, doc := p[0], p[1]
+			fmt.Fprintf(w, "<a href=%q>%s</a> - %s<br/>", p, p, doc)
+		}
 		return true
 	}
 	if vminsert.RequestHandler(w, r) {

app/vmselect/netstorage/netstorage.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/searchutils"
 	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmstorage/promdb"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/cgroup"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fasttime"
@@ -212,6 +213,12 @@ var gomaxprocs = cgroup.AvailableCPUs()
 type packedTimeseries struct {
 	metricName string
 	brs        []blockRef
+	pd         *promData
+}
+
+type promData struct {
+	values     []float64
+	timestamps []int64
 }
 
 var unpackWorkCh = make(chan *unpackWork, gomaxprocs*128)
@@ -347,10 +354,45 @@ func (pts *packedTimeseries) Unpack(dst *Result, tbf *tmpBlocksFile, tr storage.
 	if firstErr != nil {
 		return firstErr
 	}
+	if pts.pd != nil {
+		// Add data from Prometheus to dst.
+		// It usually has smaller timestamps than the data from sbs, so put it first.
+		//
+		// There is no need in check for fetchData, since this is already checked when initializing pts.pd.
+		dst.Values = append(dst.Values, pts.pd.values...)
+		dst.Timestamps = append(dst.Timestamps, pts.pd.timestamps...)
+	}
 	mergeSortBlocks(dst, sbs)
+	if pts.pd != nil {
+		if !sort.IsSorted(dst) {
+			sort.Sort(dst)
+		}
+		pts.pd = nil
+	}
 	return nil
 }
 
+// sort.Interface implementation for Result
+
+// Len implements sort.Interface
+func (r *Result) Len() int {
+	return len(r.Timestamps)
+}
+
+// Less implements sort.Interface
+func (r *Result) Less(i, j int) bool {
+	timestamps := r.Timestamps
+	return timestamps[i] < timestamps[j]
+}
+
+// Swap implements sort.Interface
+func (r *Result) Swap(i, j int) {
+	timestamps := r.Timestamps
+	values := r.Values
+	timestamps[i], timestamps[j] = timestamps[j], timestamps[i]
+	values[i], values[j] = values[j], values[i]
+}
+
 func getSortBlock() *sortBlock {
 	v := sbPool.Get()
 	if v == nil {
@@ -501,6 +543,14 @@ func GetLabelsOnTimeRange(tr storage.TimeRange, deadline searchutils.Deadline) (
 			labels[i] = "__name__"
 		}
 	}
+
+	// Merge labels obtained from Prometheus storage.
+	promLabels, err := promdb.GetLabelNamesOnTimeRange(tr, deadline)
+	if err != nil {
+		return nil, fmt.Errorf("cannot obtain labels from Prometheus storage: %w", err)
+	}
+	labels = mergeStrings(labels, promLabels)
+
 	// Sort labels like Prometheus does
 	sort.Strings(labels)
 	return labels, nil
@@ -566,11 +616,40 @@ func GetLabels(deadline searchutils.Deadline) ([]string, error) {
 			labels[i] = "__name__"
 		}
 	}
+
+	// Merge labels obtained from Prometheus storage.
+	promLabels, err := promdb.GetLabelNames(deadline)
+	if err != nil {
+		return nil, fmt.Errorf("cannot obtain labels from Prometheus storage: %w", err)
+	}
+	labels = mergeStrings(labels, promLabels)
+
 	// Sort labels like Prometheus does
 	sort.Strings(labels)
 	return labels, nil
 }
 
+func mergeStrings(a, b []string) []string {
+	if len(a) == 0 {
+		return b
+	}
+	if len(b) == 0 {
+		return a
+	}
+	m := make(map[string]struct{}, len(a)+len(b))
+	for _, s := range a {
+		m[s] = struct{}{}
+	}
+	for _, s := range b {
+		m[s] = struct{}{}
+	}
+	result := make([]string, 0, len(m))
+	for s := range m {
+		result = append(result, s)
+	}
+	return result
+}
+
 // GetLabelValuesOnTimeRange returns label values for the given labelName on the given tr
 // until the given deadline.
 func GetLabelValuesOnTimeRange(labelName string, tr storage.TimeRange, deadline searchutils.Deadline) ([]string, error) {
@@ -585,6 +664,14 @@ func GetLabelValuesOnTimeRange(labelName string, tr storage.TimeRange, deadline
 	if err != nil {
 		return nil, fmt.Errorf("error during label values search on time range for labelName=%q: %w", labelName, err)
 	}
+
+	// Merge label values obtained from Prometheus storage.
+	promLabelValues, err := promdb.GetLabelValuesOnTimeRange(labelName, tr, deadline)
+	if err != nil {
+		return nil, fmt.Errorf("cannot obtain label values on time range for %q from Prometheus storage: %w", labelName, err)
+	}
+	labelValues = mergeStrings(labelValues, promLabelValues)
+
 	// Sort labelValues like Prometheus does
 	sort.Strings(labelValues)
 	return labelValues, nil
@@ -628,6 +715,14 @@ func GetLabelValues(labelName string, deadline searchutils.Deadline) ([]string,
 	if err != nil {
 		return nil, fmt.Errorf("error during label values search for labelName=%q: %w", labelName, err)
 	}
+
+	// Merge label values obtained from Prometheus storage.
+	promLabelValues, err := promdb.GetLabelValues(labelName, deadline)
+	if err != nil {
+		return nil, fmt.Errorf("cannot obtain label values for %q from Prometheus storage: %w", labelName, err)
+	}
+	labelValues = mergeStrings(labelValues, promLabelValues)
+
 	// Sort labelValues like Prometheus does
 	sort.Strings(labelValues)
 	return labelValues, nil
@@ -960,6 +1055,26 @@ func ProcessSearchQuery(sq *storage.SearchQuery, fetchData bool, deadline search
 		return nil, fmt.Errorf("cannot finalize temporary file: %w", err)
 	}
 
+	// Fetch data from promdb.
+	pm := make(map[string]*promData)
+	err = promdb.VisitSeries(sq, fetchData, deadline, func(metricName []byte, values []float64, timestamps []int64) {
+		pd := pm[string(metricName)]
+		if pd == nil {
+			if _, ok := m[string(metricName)]; !ok {
+				orderedMetricNames = append(orderedMetricNames, string(metricName))
+			}
+			pd = &promData{}
+			pm[string(metricName)] = pd
+		}
+		pd.values = append(pd.values, values...)
+		pd.timestamps = append(pd.timestamps, timestamps...)
+	})
+	if err != nil {
+		putTmpBlocksFile(tbf)
+		putStorageSearch(sr)
+		return nil, fmt.Errorf("error when searching in Prometheus data: %w", err)
+	}
+
 	var rss Results
 	rss.tr = tr
 	rss.fetchData = fetchData
@@ -969,6 +1084,7 @@ func ProcessSearchQuery(sq *storage.SearchQuery, fetchData bool, deadline search
 		pts[i] = packedTimeseries{
 			metricName: metricName,
 			brs:        m[metricName],
+			pd:         pm[metricName],
 		}
 	}
 	rss.packedTimeseries = pts

app/vmstorage/main.go

@@ -8,6 +8,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmstorage/promdb"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/encoding"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fasttime"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/flagutil"
@@ -100,6 +101,8 @@ func InitWithoutMetrics(resetCacheIfNeeded func(mrs []storage.MetricRow)) {
 	sizeBytes := tm.SmallSizeBytes + tm.BigSizeBytes
 	logger.Infof("successfully opened storage %q in %.3f seconds; partsCount: %d; blocksCount: %d; rowsCount: %d; sizeBytes: %d",
 		*DataPath, time.Since(startTime).Seconds(), partsCount, blocksCount, rowsCount, sizeBytes)
+
+	promdb.Init(retentionPeriod.Msecs)
 }
 
 // Storage is a storage.
@@ -238,6 +241,7 @@ func Stop() {
 	logger.Infof("gracefully closing the storage at %s", *DataPath)
 	startTime := time.Now()
 	WG.WaitAndBlock()
+	promdb.MustClose()
 	Storage.MustClose()
 	logger.Infof("successfully closed the storage in %.3f seconds", time.Since(startTime).Seconds())
 

app/vmstorage/promdb/promdb.go

@@ -0,0 +1,276 @@
+package promdb
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/searchutils"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/go-kit/kit/log"
+	"github.com/oklog/ulid"
+	"github.com/prometheus/prometheus/pkg/labels"
+	promstorage "github.com/prometheus/prometheus/storage"
+	"github.com/prometheus/prometheus/tsdb"
+)
+
+var prometheusDataPath = flag.String("prometheusDataPath", "", "Optional path to readonly historical Prometheus data")
+
+var prometheusRetentionMsecs int64
+
+// Init must be called after flag.Parse and before using the package.
+//
+// See also MustClose.
+func Init(retentionMsecs int64) {
+	if promDB != nil {
+		logger.Fatalf("BUG: it looks like MustOpenPromDB is called multiple times without MustClosePromDB call")
+	}
+	prometheusRetentionMsecs = retentionMsecs
+	if *prometheusDataPath == "" {
+		return
+	}
+	l := log.LoggerFunc(func(a ...interface{}) error {
+		logger.Infof("%v", a)
+		return nil
+	})
+	opts := tsdb.DefaultOptions()
+	opts.RetentionDuration = retentionMsecs
+
+	// Set max block duration to 10% of retention period or 31 days
+	// according to https://prometheus.io/docs/prometheus/latest/storage/#compaction
+	maxBlockDuration := int64((31 * 24 * time.Hour) / time.Millisecond)
+	if maxBlockDuration > retentionMsecs/10 {
+		maxBlockDuration = retentionMsecs / 10
+	}
+	if maxBlockDuration < opts.MinBlockDuration {
+		maxBlockDuration = opts.MinBlockDuration
+	}
+	opts.MaxBlockDuration = maxBlockDuration
+
+	// Custom delete function is needed, because Prometheus by default doesn't delete
+	// blocks outside the retention if no new blocks are created with samples with the current timestamps.
+	// See https://github.com/prometheus/prometheus/blob/997bb7134fcfd7279f250e183e78681e48a56aff/tsdb/db.go#L1116
+	opts.BlocksToDelete = func(blocks []*tsdb.Block) map[ulid.ULID]struct{} {
+		m := make(map[ulid.ULID]struct{})
+		minRetentionTime := time.Now().Unix()*1000 - retentionMsecs
+		for _, block := range blocks {
+			meta := block.Meta()
+			// delete block marked for deletion by compaction code.
+			if meta.Compaction.Deletable {
+				m[meta.ULID] = struct{}{}
+				continue
+			}
+			if block.MaxTime() < minRetentionTime {
+				m[meta.ULID] = struct{}{}
+			}
+		}
+		return m
+	}
+	pdb, err := tsdb.Open(*prometheusDataPath, l, nil, opts)
+	if err != nil {
+		logger.Panicf("FATAL: cannot open Prometheus data at -prometheusDataPath=%q: %s", *prometheusDataPath, err)
+	}
+	promDB = pdb
+	logger.Infof("successfully opened historical Prometheus data at -prometheusDataPath=%q with retentionMsecs=%d", *prometheusDataPath, retentionMsecs)
+}
+
+// MustClose must be called on graceful shutdown.
+//
+// Package functionality cannot be used after this call.
+func MustClose() {
+	if *prometheusDataPath == "" {
+		return
+	}
+	if promDB == nil {
+		logger.Panicf("BUG: it looks like MustClosePromDB is called without MustOpenPromDB call")
+	}
+	if err := promDB.Close(); err != nil {
+		logger.Panicf("FATAL: cannot close promDB: %s", err)
+	}
+	promDB = nil
+	logger.Infof("successfully closed historical Prometheus data at -prometheusDataPath=%q", *prometheusDataPath)
+}
+
+var promDB *tsdb.DB
+
+// GetLabelNamesOnTimeRange returns label names.
+func GetLabelNamesOnTimeRange(tr storage.TimeRange, deadline searchutils.Deadline) ([]string, error) {
+	d := time.Unix(int64(deadline.Deadline()), 0)
+	ctx, cancel := context.WithDeadline(context.Background(), d)
+	defer cancel()
+	q, err := promDB.Querier(ctx, tr.MinTimestamp, tr.MaxTimestamp)
+	if err != nil {
+		return nil, err
+	}
+	defer mustCloseQuerier(q)
+
+	names, _, err := q.LabelNames()
+	// Make full copy of names, since they cannot be used after q is closed.
+	names = copyStringsWithMemory(names)
+	return names, err
+}
+
+// GetLabelNames returns label names.
+func GetLabelNames(deadline searchutils.Deadline) ([]string, error) {
+	tr := storage.TimeRange{
+		MinTimestamp: 0,
+		MaxTimestamp: time.Now().UnixNano() / 1e6,
+	}
+	return GetLabelNamesOnTimeRange(tr, deadline)
+}
+
+// GetLabelValuesOnTimeRange returns values for the given labelName on the given tr.
+func GetLabelValuesOnTimeRange(labelName string, tr storage.TimeRange, deadline searchutils.Deadline) ([]string, error) {
+	d := time.Unix(int64(deadline.Deadline()), 0)
+	ctx, cancel := context.WithDeadline(context.Background(), d)
+	defer cancel()
+	q, err := promDB.Querier(ctx, tr.MinTimestamp, tr.MaxTimestamp)
+	if err != nil {
+		return nil, err
+	}
+	defer mustCloseQuerier(q)
+
+	values, _, err := q.LabelValues(labelName)
+	// Make full copy of values, since they cannot be used after q is closed.
+	values = copyStringsWithMemory(values)
+	return values, err
+}
+
+// GetLabelValues returns values for the given labelName.
+func GetLabelValues(labelName string, deadline searchutils.Deadline) ([]string, error) {
+	tr := storage.TimeRange{
+		MinTimestamp: 0,
+		MaxTimestamp: time.Now().UnixNano() / 1e6,
+	}
+	return GetLabelValuesOnTimeRange(labelName, tr, deadline)
+}
+
+func copyStringsWithMemory(a []string) []string {
+	result := make([]string, len(a))
+	for i, s := range a {
+		result[i] = string(append([]byte{}, s...))
+	}
+	return result
+}
+
+// SeriesVisitor is called by VisitSeries for each matching time series.
+//
+// The caller shouldn't hold references to metricName, values and timestamps after returning.
+type SeriesVisitor func(metricName []byte, values []float64, timestamps []int64)
+
+// VisitSeries calls f for each series found in the pdb.
+//
+// If fetchData is false, then empty values and timestamps are passed to f.
+func VisitSeries(sq *storage.SearchQuery, fetchData bool, deadline searchutils.Deadline, f SeriesVisitor) error {
+	if *prometheusDataPath == "" {
+		return nil
+	}
+	d := time.Unix(int64(deadline.Deadline()), 0)
+	ctx, cancel := context.WithDeadline(context.Background(), d)
+	defer cancel()
+	minTime, maxTime := getSearchTimeRange(sq)
+	q, err := promDB.Querier(ctx, minTime, maxTime)
+	if err != nil {
+		return err
+	}
+	defer mustCloseQuerier(q)
+	var seriesSet []promstorage.SeriesSet
+	for _, tf := range sq.TagFilterss {
+		ms, err := convertTagFiltersToMatchers(tf)
+		if err != nil {
+			return fmt.Errorf("cannot convert tag filters to matchers: %w", err)
+		}
+		s := q.Select(false, nil, ms...)
+		seriesSet = append(seriesSet, s)
+	}
+	ss := promstorage.NewMergeSeriesSet(seriesSet, promstorage.ChainedSeriesMerge)
+	var (
+		mn         storage.MetricName
+		metricName []byte
+		values     []float64
+		timestamps []int64
+	)
+	for ss.Next() {
+		s := ss.At()
+		convertPromLabelsToMetricName(&mn, s.Labels())
+		metricName = mn.SortAndMarshal(metricName[:0])
+		values = values[:0]
+		timestamps = timestamps[:0]
+		if fetchData {
+			it := s.Iterator()
+			for it.Next() {
+				ts, v := it.At()
+				values = append(values, v)
+				timestamps = append(timestamps, ts)
+			}
+			if err := it.Err(); err != nil {
+				return fmt.Errorf("error when iterating Prometheus series: %w", err)
+			}
+		}
+		f(metricName, values, timestamps)
+	}
+	return ss.Err()
+}
+
+func getSearchTimeRange(sq *storage.SearchQuery) (int64, int64) {
+	maxTime := sq.MaxTimestamp
+	minTime := sq.MinTimestamp
+	minRetentionTime := time.Now().Unix()*1000 - prometheusRetentionMsecs
+	if maxTime < minRetentionTime {
+		maxTime = minRetentionTime
+	}
+	if minTime < minRetentionTime {
+		minTime = minRetentionTime
+	}
+	return minTime, maxTime
+}
+
+func convertPromLabelsToMetricName(dst *storage.MetricName, labels []labels.Label) {
+	dst.Reset()
+	for _, label := range labels {
+		if label.Name == "__name__" {
+			dst.MetricGroup = append(dst.MetricGroup[:0], label.Value...)
+		} else {
+			dst.AddTag(label.Name, label.Value)
+		}
+	}
+}
+
+func convertTagFiltersToMatchers(tfs []storage.TagFilter) ([]*labels.Matcher, error) {
+	ms := make([]*labels.Matcher, 0, len(tfs))
+	for _, tf := range tfs {
+		var mt labels.MatchType
+		if tf.IsNegative {
+			if tf.IsRegexp {
+				mt = labels.MatchNotRegexp
+			} else {
+				mt = labels.MatchNotEqual
+			}
+		} else {
+			if tf.IsRegexp {
+				mt = labels.MatchRegexp
+			} else {
+				mt = labels.MatchEqual
+			}
+		}
+		key := string(tf.Key)
+		if key == "" {
+			key = "__name__"
+		}
+		value := string(tf.Value)
+		m, err := labels.NewMatcher(mt, key, value)
+		if err != nil {
+			return nil, err
+		}
+		ms = append(ms, m)
+	}
+	return ms, nil
+}
+
+func mustCloseQuerier(q promstorage.Querier) {
+	if err := q.Close(); err != nil {
+		logger.Panicf("FATAL: cannot close querier: %s", err)
+	}
+}

go.mod

@@ -16,13 +16,14 @@ require (
 	github.com/cheggaaa/pb/v3 v3.0.8
 	github.com/cpuguy83/go-md2man/v2 v2.0.0 // indirect
 	github.com/fatih/color v1.12.0 // indirect
-	github.com/go-kit/kit v0.11.0 // indirect
+	github.com/go-kit/kit v0.11.0
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
 	github.com/golang/snappy v0.0.4
 	github.com/influxdata/influxdb v1.9.3
 	github.com/klauspost/compress v1.13.1
 	github.com/mattn/go-isatty v0.0.13 // indirect
 	github.com/mattn/go-runewidth v0.0.13 // indirect
+	github.com/oklog/ulid v1.3.1
 	github.com/prometheus/common v0.29.0 // indirect
 	github.com/prometheus/procfs v0.7.0 // indirect
 	github.com/prometheus/prometheus v1.8.2-0.20201119142752-3ad25a6dc3d9

lib/storage/metric_name.go

@@ -358,6 +358,12 @@ func (mn *MetricName) String() string {
 	return fmt.Sprintf("%s{%s}", mnCopy.MetricGroup, tagsStr)
 }
 
+// SortAndMarshal sorts mn tags and then marshals them to dst.
+func (mn *MetricName) SortAndMarshal(dst []byte) []byte {
+	mn.sortTags()
+	return mn.Marshal(dst)
+}
+
 // Marshal appends marshaled mn to dst and returns the result.
 //
 // mn.sortTags must be called before calling this function

vendor/modules.txt

@@ -149,6 +149,7 @@ github.com/mattn/go-runewidth
 # github.com/matttproud/golang_protobuf_extensions v1.0.1
 github.com/matttproud/golang_protobuf_extensions/pbutil
 # github.com/oklog/ulid v1.3.1
+## explicit
 github.com/oklog/ulid
 # github.com/pkg/errors v0.9.1
 github.com/pkg/errors