2016-11-15 09:34:25 +00:00
|
|
|
// Package tsdb implements a time series storage for float64 sample data.
|
|
|
|
package tsdb
|
|
|
|
|
|
|
|
import (
|
2016-12-10 17:08:50 +00:00
|
|
|
"bytes"
|
2016-12-04 12:16:11 +00:00
|
|
|
"fmt"
|
|
|
|
"os"
|
2016-12-08 16:43:10 +00:00
|
|
|
"path/filepath"
|
2016-12-15 10:56:41 +00:00
|
|
|
"reflect"
|
2016-12-15 07:31:26 +00:00
|
|
|
"strconv"
|
2016-12-08 16:43:10 +00:00
|
|
|
"sync"
|
2016-11-15 09:34:25 +00:00
|
|
|
"time"
|
2016-12-15 10:56:41 +00:00
|
|
|
"unsafe"
|
2016-11-15 09:34:25 +00:00
|
|
|
|
2016-12-15 07:31:26 +00:00
|
|
|
"golang.org/x/sync/errgroup"
|
|
|
|
|
2016-12-08 16:43:10 +00:00
|
|
|
"github.com/fabxc/tsdb/chunks"
|
2016-12-21 08:39:01 +00:00
|
|
|
"github.com/fabxc/tsdb/labels"
|
2016-12-14 17:38:46 +00:00
|
|
|
"github.com/go-kit/kit/log"
|
2016-12-31 08:48:49 +00:00
|
|
|
"github.com/prometheus/client_golang/prometheus"
|
2016-11-15 09:34:25 +00:00
|
|
|
)
|
|
|
|
|
2016-12-09 09:00:14 +00:00
|
|
|
// DefaultOptions used for the DB. They are sane for setups using
|
|
|
|
// millisecond precision timestamps.
|
2016-11-15 09:34:25 +00:00
|
|
|
var DefaultOptions = &Options{
|
2016-12-26 15:55:44 +00:00
|
|
|
Retention: 15 * 24 * 3600 * 1000, // 15 days
|
|
|
|
DisableWAL: false,
|
2016-11-15 09:34:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Options of the DB storage.
|
|
|
|
type Options struct {
|
2016-12-26 15:55:44 +00:00
|
|
|
Retention int64
|
|
|
|
DisableWAL bool
|
2016-11-15 09:34:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// DB is a time series storage.
|
|
|
|
type DB struct {
|
|
|
|
logger log.Logger
|
|
|
|
opts *Options
|
2016-12-08 16:43:10 +00:00
|
|
|
path string
|
2016-11-15 09:34:25 +00:00
|
|
|
|
2016-12-15 07:36:09 +00:00
|
|
|
shards []*Shard
|
2016-11-15 09:34:25 +00:00
|
|
|
}
|
|
|
|
|
2016-12-04 12:16:11 +00:00
|
|
|
// TODO(fabxc): make configurable
|
|
|
|
const (
|
2016-12-31 08:48:49 +00:00
|
|
|
shardShift = 2
|
2016-12-15 07:36:09 +00:00
|
|
|
numShards = 1 << shardShift
|
|
|
|
maxChunkSize = 1024
|
2016-12-04 12:16:11 +00:00
|
|
|
)
|
|
|
|
|
2016-11-15 09:34:25 +00:00
|
|
|
// Open or create a new DB.
|
|
|
|
func Open(path string, l log.Logger, opts *Options) (*DB, error) {
|
|
|
|
if opts == nil {
|
|
|
|
opts = DefaultOptions
|
|
|
|
}
|
2016-12-04 12:16:11 +00:00
|
|
|
if err := os.MkdirAll(path, 0777); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2016-12-14 17:38:46 +00:00
|
|
|
if l == nil {
|
|
|
|
l = log.NewLogfmtLogger(os.Stdout)
|
|
|
|
l = log.NewContext(l).With("ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller)
|
|
|
|
}
|
2016-11-15 09:34:25 +00:00
|
|
|
|
|
|
|
c := &DB{
|
2016-12-04 12:16:11 +00:00
|
|
|
logger: l,
|
|
|
|
opts: opts,
|
2016-12-08 16:43:10 +00:00
|
|
|
path: path,
|
2016-11-15 09:34:25 +00:00
|
|
|
}
|
|
|
|
|
2016-12-04 12:16:11 +00:00
|
|
|
// Initialize vertical shards.
|
|
|
|
// TODO(fabxc): validate shard number to be power of 2, which is required
|
|
|
|
// for the bitshift-modulo when finding the right shard.
|
2016-12-15 07:36:09 +00:00
|
|
|
for i := 0; i < numShards; i++ {
|
2016-12-14 17:38:46 +00:00
|
|
|
l := log.NewContext(l).With("shard", i)
|
2016-12-15 07:31:26 +00:00
|
|
|
d := shardDir(path, i)
|
|
|
|
|
2016-12-31 08:48:49 +00:00
|
|
|
s, err := OpenShard(d, i, l)
|
2016-12-15 07:31:26 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("initializing shard %q failed: %s", d, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
c.shards = append(c.shards, s)
|
2016-12-04 12:16:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// TODO(fabxc): run background compaction + GC.
|
|
|
|
|
2016-11-15 09:34:25 +00:00
|
|
|
return c, nil
|
|
|
|
}
|
|
|
|
|
2016-12-15 07:31:26 +00:00
|
|
|
func shardDir(base string, i int) string {
|
|
|
|
return filepath.Join(base, strconv.Itoa(i))
|
|
|
|
}
|
|
|
|
|
2016-12-04 12:16:11 +00:00
|
|
|
// Close the database.
|
|
|
|
func (db *DB) Close() error {
|
2016-12-15 07:31:26 +00:00
|
|
|
var g errgroup.Group
|
2016-12-09 09:00:14 +00:00
|
|
|
|
2016-12-15 07:31:26 +00:00
|
|
|
for _, shard := range db.shards {
|
|
|
|
// Fix closure argument to goroutine.
|
|
|
|
shard := shard
|
|
|
|
g.Go(shard.Close)
|
2016-12-07 16:10:49 +00:00
|
|
|
}
|
2016-12-09 09:00:14 +00:00
|
|
|
|
2016-12-15 07:31:26 +00:00
|
|
|
return g.Wait()
|
2016-12-04 12:16:11 +00:00
|
|
|
}
|
|
|
|
|
2016-12-20 23:02:37 +00:00
|
|
|
// Appender allows committing batches of samples to a database.
|
|
|
|
// The data held by the appender is reset after Commit returns.
|
2016-12-10 17:08:50 +00:00
|
|
|
type Appender interface {
|
2016-12-20 23:02:37 +00:00
|
|
|
// AddSeries registers a new known series label set with the appender
|
|
|
|
// and returns a reference number used to add samples to it over the
|
|
|
|
// life time of the Appender.
|
|
|
|
// AddSeries(Labels) uint64
|
2016-12-10 17:08:50 +00:00
|
|
|
|
2016-12-20 23:02:37 +00:00
|
|
|
// Add adds a sample pair for the referenced series.
|
2016-12-29 10:03:39 +00:00
|
|
|
Add(lset labels.Labels, t int64, v float64) error
|
2016-12-20 23:02:37 +00:00
|
|
|
|
|
|
|
// Commit submits the collected samples and purges the batch.
|
2016-12-10 17:08:50 +00:00
|
|
|
Commit() error
|
|
|
|
}
|
|
|
|
|
2016-12-20 23:02:37 +00:00
|
|
|
// Appender returns a new appender against the database.
|
|
|
|
func (db *DB) Appender() Appender {
|
|
|
|
return &bucketAppender{
|
|
|
|
db: db,
|
|
|
|
buckets: make([][]hashedSample, numShards),
|
|
|
|
}
|
2016-12-10 17:08:50 +00:00
|
|
|
}
|
|
|
|
|
2016-12-20 23:02:37 +00:00
|
|
|
type bucketAppender struct {
|
|
|
|
db *DB
|
|
|
|
buckets [][]hashedSample
|
2016-12-10 17:08:50 +00:00
|
|
|
}
|
|
|
|
|
2016-12-29 10:03:39 +00:00
|
|
|
func (ba *bucketAppender) Add(lset labels.Labels, t int64, v float64) error {
|
2016-12-10 17:08:50 +00:00
|
|
|
h := lset.Hash()
|
2016-12-20 23:02:37 +00:00
|
|
|
s := h >> (64 - shardShift)
|
2016-12-10 17:08:50 +00:00
|
|
|
|
2016-12-20 23:02:37 +00:00
|
|
|
ba.buckets[s] = append(ba.buckets[s], hashedSample{
|
|
|
|
hash: h,
|
|
|
|
labels: lset,
|
|
|
|
t: t,
|
|
|
|
v: v,
|
2016-12-10 17:08:50 +00:00
|
|
|
})
|
2016-12-29 10:03:39 +00:00
|
|
|
|
|
|
|
return nil
|
2016-12-10 17:08:50 +00:00
|
|
|
}
|
|
|
|
|
2016-12-20 23:02:37 +00:00
|
|
|
func (ba *bucketAppender) reset() {
|
|
|
|
for i := range ba.buckets {
|
|
|
|
ba.buckets[i] = ba.buckets[i][:0]
|
2016-12-09 12:41:38 +00:00
|
|
|
}
|
2016-12-20 23:02:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ba *bucketAppender) Commit() error {
|
|
|
|
defer ba.reset()
|
2016-12-09 12:41:38 +00:00
|
|
|
|
2016-12-20 23:02:37 +00:00
|
|
|
var merr MultiError
|
|
|
|
|
|
|
|
// Spill buckets into shards.
|
|
|
|
for s, b := range ba.buckets {
|
|
|
|
merr.Add(ba.db.shards[s].appendBatch(b))
|
|
|
|
}
|
|
|
|
return merr.Err()
|
2016-12-09 12:41:38 +00:00
|
|
|
}
|
|
|
|
|
2016-12-20 23:02:37 +00:00
|
|
|
type hashedSample struct {
|
|
|
|
hash uint64
|
2016-12-21 08:39:01 +00:00
|
|
|
labels labels.Labels
|
2016-12-22 11:05:24 +00:00
|
|
|
ref uint32
|
2016-12-20 23:02:37 +00:00
|
|
|
|
|
|
|
t int64
|
|
|
|
v float64
|
2016-12-09 15:54:38 +00:00
|
|
|
}
|
|
|
|
|
2016-12-09 09:00:14 +00:00
|
|
|
const sep = '\xff'
|
|
|
|
|
2016-12-15 07:36:09 +00:00
|
|
|
// Shard handles reads and writes of time series falling into
|
2016-12-09 09:00:14 +00:00
|
|
|
// a hashed shard of a series.
|
2016-12-15 07:36:09 +00:00
|
|
|
type Shard struct {
|
2016-12-09 12:41:38 +00:00
|
|
|
path string
|
|
|
|
persistCh chan struct{}
|
|
|
|
logger log.Logger
|
2016-12-31 08:48:49 +00:00
|
|
|
metrics *shardMetrics
|
2016-12-09 09:00:14 +00:00
|
|
|
|
2016-12-15 07:31:26 +00:00
|
|
|
mtx sync.RWMutex
|
|
|
|
persisted persistedBlocks
|
|
|
|
head *HeadBlock
|
2016-12-09 09:00:14 +00:00
|
|
|
}
|
|
|
|
|
2016-12-31 08:48:49 +00:00
|
|
|
type shardMetrics struct {
|
|
|
|
persistences prometheus.Counter
|
|
|
|
persistenceDuration prometheus.Histogram
|
|
|
|
samplesAppended prometheus.Counter
|
|
|
|
}
|
|
|
|
|
|
|
|
func newShardMetrics(r prometheus.Registerer, i int) *shardMetrics {
|
|
|
|
shardLabel := prometheus.Labels{
|
|
|
|
"shard": fmt.Sprintf("%d", i),
|
|
|
|
}
|
|
|
|
|
|
|
|
m := &shardMetrics{
|
|
|
|
persistences: prometheus.NewCounter(prometheus.CounterOpts{
|
|
|
|
Name: "tsdb_shard_persistences_total",
|
|
|
|
Help: "Total number of head persistances that ran so far.",
|
|
|
|
ConstLabels: shardLabel,
|
|
|
|
}),
|
|
|
|
persistenceDuration: prometheus.NewHistogram(prometheus.HistogramOpts{
|
|
|
|
Name: "tsdb_shard_persistence_duration_seconds",
|
|
|
|
Help: "Duration of persistences in seconds.",
|
|
|
|
ConstLabels: shardLabel,
|
|
|
|
Buckets: prometheus.ExponentialBuckets(0.25, 2, 5),
|
|
|
|
}),
|
|
|
|
samplesAppended: prometheus.NewCounter(prometheus.CounterOpts{
|
|
|
|
Name: "tsdb_shard_samples_appended_total",
|
|
|
|
Help: "Total number of appended samples for the shard.",
|
|
|
|
ConstLabels: shardLabel,
|
|
|
|
}),
|
|
|
|
}
|
|
|
|
|
|
|
|
if r != nil {
|
|
|
|
r.MustRegister(
|
|
|
|
m.persistences,
|
|
|
|
m.persistenceDuration,
|
|
|
|
m.samplesAppended,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
2016-12-15 07:36:09 +00:00
|
|
|
// OpenShard returns a new Shard.
|
2016-12-31 08:48:49 +00:00
|
|
|
func OpenShard(path string, i int, logger log.Logger) (*Shard, error) {
|
2016-12-15 07:31:26 +00:00
|
|
|
// Create directory if shard is new.
|
|
|
|
if _, err := os.Stat(path); os.IsNotExist(err) {
|
|
|
|
if err := os.MkdirAll(path, 0777); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize previously persisted blocks.
|
2016-12-22 14:54:39 +00:00
|
|
|
pbs, head, err := findBlocks(path)
|
2016-12-15 07:31:26 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2016-12-22 11:05:24 +00:00
|
|
|
// TODO(fabxc): get time from client-defined `now` function.
|
2016-12-28 07:50:20 +00:00
|
|
|
// baset := time.Now().UnixNano() / int64(time.Millisecond)
|
|
|
|
baset := time.Unix(0, 0).UnixNano() / int64(time.Millisecond)
|
2016-12-22 11:05:24 +00:00
|
|
|
if len(pbs) > 0 {
|
2016-12-22 14:54:39 +00:00
|
|
|
baset = pbs[len(pbs)-1].stats.MaxTime
|
2016-12-22 11:05:24 +00:00
|
|
|
}
|
2016-12-22 14:54:39 +00:00
|
|
|
if head == nil {
|
2016-12-22 19:00:24 +00:00
|
|
|
head, err = OpenHeadBlock(filepath.Join(path, fmt.Sprintf("%d", baset)), baset)
|
2016-12-22 14:54:39 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2016-12-22 11:05:24 +00:00
|
|
|
}
|
|
|
|
|
2016-12-15 07:36:09 +00:00
|
|
|
s := &Shard{
|
2016-12-09 12:41:38 +00:00
|
|
|
path: path,
|
|
|
|
persistCh: make(chan struct{}, 1),
|
|
|
|
logger: logger,
|
2016-12-31 08:48:49 +00:00
|
|
|
metrics: newShardMetrics(prometheus.DefaultRegisterer, i),
|
2016-12-22 11:05:24 +00:00
|
|
|
head: head,
|
2016-12-15 07:31:26 +00:00
|
|
|
persisted: pbs,
|
2016-12-09 09:00:14 +00:00
|
|
|
}
|
2016-12-15 07:31:26 +00:00
|
|
|
return s, nil
|
2016-12-09 12:41:38 +00:00
|
|
|
}
|
|
|
|
|
2016-12-15 07:36:09 +00:00
|
|
|
// Close the shard.
|
|
|
|
func (s *Shard) Close() error {
|
2016-12-28 10:41:44 +00:00
|
|
|
s.mtx.Lock()
|
|
|
|
defer s.mtx.Unlock()
|
|
|
|
|
2016-12-15 07:31:26 +00:00
|
|
|
var e MultiError
|
|
|
|
|
|
|
|
for _, pb := range s.persisted {
|
|
|
|
e.Add(pb.Close())
|
|
|
|
}
|
2016-12-22 11:05:24 +00:00
|
|
|
e.Add(s.head.Close())
|
2016-12-15 07:31:26 +00:00
|
|
|
|
|
|
|
return e.Err()
|
2016-12-09 09:00:14 +00:00
|
|
|
}
|
|
|
|
|
2016-12-20 23:02:37 +00:00
|
|
|
func (s *Shard) appendBatch(samples []hashedSample) error {
|
2016-12-31 14:35:08 +00:00
|
|
|
if len(samples) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
2016-12-09 12:41:38 +00:00
|
|
|
s.mtx.Lock()
|
|
|
|
defer s.mtx.Unlock()
|
|
|
|
|
2016-12-22 00:12:28 +00:00
|
|
|
// TODO(fabxc): distinguish samples between concurrent heads for
|
|
|
|
// different time blocks. Those may occurr during transition to still
|
|
|
|
// allow late samples to arrive for a previous block.
|
2016-12-31 09:19:02 +00:00
|
|
|
err := s.head.appendBatch(samples)
|
2016-12-31 14:35:08 +00:00
|
|
|
if err == nil {
|
2016-12-31 09:19:02 +00:00
|
|
|
s.metrics.samplesAppended.Add(float64(len(samples)))
|
|
|
|
}
|
2016-12-09 12:41:38 +00:00
|
|
|
|
2016-12-22 00:12:28 +00:00
|
|
|
// TODO(fabxc): randomize over time and use better scoring function.
|
2016-12-31 08:48:49 +00:00
|
|
|
if s.head.stats.SampleCount/(uint64(s.head.stats.ChunkCount)+1) > 400 {
|
2016-12-09 12:41:38 +00:00
|
|
|
select {
|
|
|
|
case s.persistCh <- struct{}{}:
|
2016-12-19 21:29:49 +00:00
|
|
|
go func() {
|
2016-12-31 08:48:49 +00:00
|
|
|
start := time.Now()
|
|
|
|
defer func() { s.metrics.persistenceDuration.Observe(time.Since(start).Seconds()) }()
|
|
|
|
|
2016-12-19 21:29:49 +00:00
|
|
|
if err := s.persist(); err != nil {
|
|
|
|
s.logger.Log("msg", "persistance error", "err", err)
|
|
|
|
}
|
2016-12-31 08:48:49 +00:00
|
|
|
s.metrics.persistences.Inc()
|
2016-12-19 21:29:49 +00:00
|
|
|
}()
|
2016-12-09 12:41:38 +00:00
|
|
|
default:
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-22 00:12:28 +00:00
|
|
|
return err
|
2016-12-09 12:41:38 +00:00
|
|
|
}
|
|
|
|
|
2016-12-15 15:14:33 +00:00
|
|
|
func intervalOverlap(amin, amax, bmin, bmax int64) bool {
|
|
|
|
if bmin >= amin && bmin <= amax {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
if amin >= bmin && amin <= bmax {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2016-12-16 11:13:17 +00:00
|
|
|
func intervalContains(min, max, t int64) bool {
|
|
|
|
return t >= min && t <= max
|
|
|
|
}
|
|
|
|
|
2016-12-13 14:26:58 +00:00
|
|
|
// blocksForRange returns all blocks within the shard that may contain
|
|
|
|
// data for the given time range.
|
2016-12-15 15:14:33 +00:00
|
|
|
func (s *Shard) blocksForInterval(mint, maxt int64) []block {
|
|
|
|
var bs []block
|
|
|
|
|
|
|
|
for _, b := range s.persisted {
|
|
|
|
bmin, bmax := b.interval()
|
|
|
|
|
|
|
|
if intervalOverlap(mint, maxt, bmin, bmax) {
|
|
|
|
bs = append(bs, b)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
hmin, hmax := s.head.interval()
|
|
|
|
|
|
|
|
if intervalOverlap(mint, maxt, hmin, hmax) {
|
|
|
|
bs = append(bs, s.head)
|
|
|
|
}
|
|
|
|
|
|
|
|
return bs
|
2016-12-13 14:26:58 +00:00
|
|
|
}
|
|
|
|
|
2016-12-09 12:41:38 +00:00
|
|
|
// TODO(fabxc): make configurable.
|
|
|
|
const shardGracePeriod = 60 * 1000 // 60 seconds for millisecond scale
|
|
|
|
|
2016-12-15 07:36:09 +00:00
|
|
|
func (s *Shard) persist() error {
|
2016-12-09 12:41:38 +00:00
|
|
|
s.mtx.Lock()
|
|
|
|
|
|
|
|
// Set new head block.
|
|
|
|
head := s.head
|
2016-12-22 19:00:24 +00:00
|
|
|
newHead, err := OpenHeadBlock(filepath.Join(s.path, fmt.Sprintf("%d", head.stats.MaxTime)), head.stats.MaxTime)
|
2016-12-22 11:05:24 +00:00
|
|
|
if err != nil {
|
|
|
|
s.mtx.Unlock()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
s.head = newHead
|
2016-12-09 12:41:38 +00:00
|
|
|
|
|
|
|
s.mtx.Unlock()
|
|
|
|
|
2016-12-18 13:43:27 +00:00
|
|
|
// Only allow another persistence to be triggered after the current one
|
|
|
|
// has completed (successful or not.)
|
2016-12-09 12:41:38 +00:00
|
|
|
defer func() {
|
|
|
|
<-s.persistCh
|
|
|
|
}()
|
|
|
|
|
|
|
|
// TODO(fabxc): add grace period where we can still append to old head shard
|
|
|
|
// before actually persisting it.
|
2016-12-15 15:14:33 +00:00
|
|
|
p := filepath.Join(s.path, fmt.Sprintf("%d", head.stats.MinTime))
|
2016-12-09 12:41:38 +00:00
|
|
|
|
|
|
|
if err := os.MkdirAll(p, 0777); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-12-19 21:37:03 +00:00
|
|
|
n, err := head.persist(p)
|
2016-12-09 20:23:34 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2016-12-19 21:37:03 +00:00
|
|
|
sz := fmt.Sprintf("%.2fMiB", float64(n)/1024/1024)
|
2016-12-15 15:14:33 +00:00
|
|
|
s.logger.Log("size", sz, "samples", head.stats.SampleCount, "chunks", head.stats.ChunkCount, "msg", "persisted head")
|
2016-12-09 12:41:38 +00:00
|
|
|
|
2016-12-18 13:43:27 +00:00
|
|
|
// Reopen block as persisted block for querying.
|
|
|
|
pb, err := newPersistedBlock(p)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
s.mtx.Lock()
|
|
|
|
s.persisted = append(s.persisted, pb)
|
|
|
|
s.mtx.Unlock()
|
|
|
|
|
2016-12-09 12:41:38 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-12-09 09:00:14 +00:00
|
|
|
// chunkDesc wraps a plain data chunk and provides cached meta data about it.
|
|
|
|
type chunkDesc struct {
|
2016-12-31 09:19:02 +00:00
|
|
|
ref uint32
|
2016-12-21 08:39:01 +00:00
|
|
|
lset labels.Labels
|
2016-12-09 09:00:14 +00:00
|
|
|
chunk chunks.Chunk
|
|
|
|
|
|
|
|
// Caching fields.
|
2016-12-16 11:13:17 +00:00
|
|
|
firsTimestamp int64
|
2016-12-09 09:00:14 +00:00
|
|
|
lastTimestamp int64
|
|
|
|
lastValue float64
|
2016-12-22 19:57:00 +00:00
|
|
|
numSamples int
|
2016-12-09 09:00:14 +00:00
|
|
|
|
|
|
|
app chunks.Appender // Current appender for the chunks.
|
|
|
|
}
|
|
|
|
|
2016-12-31 09:10:27 +00:00
|
|
|
func (cd *chunkDesc) append(ts int64, v float64) {
|
|
|
|
if cd.numSamples == 0 {
|
2016-12-16 11:13:17 +00:00
|
|
|
cd.firsTimestamp = ts
|
2016-12-09 09:00:14 +00:00
|
|
|
}
|
2016-12-31 09:10:27 +00:00
|
|
|
cd.app.Append(ts, v)
|
2016-12-09 09:00:14 +00:00
|
|
|
|
|
|
|
cd.lastTimestamp = ts
|
|
|
|
cd.lastValue = v
|
2016-12-22 19:57:00 +00:00
|
|
|
cd.numSamples++
|
2016-12-09 09:00:14 +00:00
|
|
|
}
|
|
|
|
|
2016-12-10 17:08:50 +00:00
|
|
|
// The MultiError type implements the error interface, and contains the
|
|
|
|
// Errors used to construct it.
|
|
|
|
type MultiError []error
|
2016-12-07 16:10:49 +00:00
|
|
|
|
2016-12-10 17:08:50 +00:00
|
|
|
// Returns a concatenated string of the contained errors
|
|
|
|
func (es MultiError) Error() string {
|
|
|
|
var buf bytes.Buffer
|
2016-12-07 16:10:49 +00:00
|
|
|
|
2016-12-10 17:08:50 +00:00
|
|
|
if len(es) > 0 {
|
|
|
|
fmt.Fprintf(&buf, "%d errors: ", len(es))
|
2016-12-08 09:04:24 +00:00
|
|
|
}
|
2016-12-07 16:10:49 +00:00
|
|
|
|
2016-12-10 17:08:50 +00:00
|
|
|
for i, err := range es {
|
|
|
|
if i != 0 {
|
|
|
|
buf.WriteString("; ")
|
|
|
|
}
|
|
|
|
buf.WriteString(err.Error())
|
|
|
|
}
|
2016-12-07 16:10:49 +00:00
|
|
|
|
2016-12-10 17:08:50 +00:00
|
|
|
return buf.String()
|
2016-11-15 09:34:25 +00:00
|
|
|
}
|
2016-12-15 07:31:26 +00:00
|
|
|
|
2016-12-15 10:56:41 +00:00
|
|
|
// Add adds the error to the error list if it is not nil.
|
2016-12-31 14:35:08 +00:00
|
|
|
func (es *MultiError) Add(err error) {
|
|
|
|
if err == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if merr, ok := err.(MultiError); ok {
|
|
|
|
*es = append(*es, merr...)
|
|
|
|
} else {
|
|
|
|
*es = append(*es, err)
|
2016-12-15 07:31:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-15 10:56:41 +00:00
|
|
|
// Err returns the error list as an error or nil if it is empty.
|
2016-12-15 07:31:26 +00:00
|
|
|
func (es MultiError) Err() error {
|
|
|
|
if len(es) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return es
|
|
|
|
}
|
2016-12-15 10:56:41 +00:00
|
|
|
|
|
|
|
func yoloString(b []byte) string {
|
|
|
|
h := reflect.StringHeader{
|
|
|
|
Data: uintptr(unsafe.Pointer(&b[0])),
|
|
|
|
Len: len(b),
|
|
|
|
}
|
|
|
|
return *((*string)(unsafe.Pointer(&h)))
|
|
|
|
}
|
|
|
|
|
|
|
|
func yoloBytes(s string) []byte {
|
|
|
|
sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
|
|
|
|
|
|
|
|
h := reflect.SliceHeader{
|
|
|
|
Cap: sh.Len,
|
|
|
|
Len: sh.Len,
|
|
|
|
Data: sh.Data,
|
|
|
|
}
|
|
|
|
return *((*[]byte)(unsafe.Pointer(&h)))
|
|
|
|
}
|