diff --git a/tsdb/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
similarity index 91%
rename from tsdb/.github/PULL_REQUEST_TEMPLATE.md
rename to .github/PULL_REQUEST_TEMPLATE.md
index bbde6132db..3f55b8ea91 100644
--- a/tsdb/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,8 +1,6 @@
 <!--
     Don't forget!
     
-    - Most PRs would require a CHANGELOG entry.
-    
     - If the PR adds or changes a behaviour or fixes a bug of an exported API it would need a unit/e2e test.
     
     - Where possible use only exported APIs for tests to simplify the review and make it as close as possible to an actual library usage.
diff --git a/.travis.yml b/.travis.yml
index f1e2287aae..bc5c94f660 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -12,6 +12,7 @@ go_import_path: github.com/prometheus/prometheus
 # random issues on Travis.
 before_install:
 - travis_retry make deps
+- if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then choco install make; fi
 
 script:
 - make check_license style unused test lint check_assets
diff --git a/Makefile b/Makefile
index 6b13f9b67c..11d4fa508e 100644
--- a/Makefile
+++ b/Makefile
@@ -14,6 +14,13 @@
 # Needs to be defined before including Makefile.common to auto-generate targets
 DOCKER_ARCHS ?= amd64 armv7 arm64
 
+TSDB_PROJECT_DIR = "./tsdb"
+TSDB_CLI_DIR="$(TSDB_PROJECT_DIR)/cmd/tsdb"
+TSDB_BIN = "$(TSDB_CLI_DIR)/tsdb"
+TSDB_BENCHMARK_NUM_METRICS ?= 1000
+TSDB_BENCHMARK_DATASET ?= "$(TSDB_PROJECT_DIR)/testdata/20kseries.json"
+TSDB_BENCHMARK_OUTPUT_DIR ?= "$(TSDB_CLI_DIR)/benchout"
+
 include Makefile.common
 
 DOCKER_IMAGE_NAME       ?= prometheus
@@ -31,3 +38,15 @@ check_assets: assets
 		echo "Run 'make assets' and commit the changes to fix the error."; \
 		exit 1; \
 	fi
+
+build_tsdb:
+	GO111MODULE=$(GO111MODULE) $(GO) build -o $(TSDB_BIN) $(TSDB_CLI_DIR)
+
+bench_tsdb: build_tsdb
+	@echo ">> running benchmark, writing result to $(TSDB_BENCHMARK_OUTPUT_DIR)"
+	@$(TSDB_BIN) bench write --metrics=$(TSDB_BENCHMARK_NUM_METRICS) --out=$(TSDB_BENCHMARK_OUTPUT_DIR) $(TSDB_BENCHMARK_DATASET)
+	@$(GO) tool pprof -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/cpu.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/cpuprof.svg
+	@$(GO) tool pprof --inuse_space -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/mem.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/memprof.inuse.svg
+	@$(GO) tool pprof --alloc_space -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/mem.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/memprof.alloc.svg
+	@$(GO) tool pprof -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/block.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/blockprof.svg
+	@$(GO) tool pprof -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/mutex.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/mutexprof.svg
diff --git a/discovery/consul/consul_test.go b/discovery/consul/consul_test.go
index bfaaba8d4e..557cd9a2b9 100644
--- a/discovery/consul/consul_test.go
+++ b/discovery/consul/consul_test.go
@@ -79,7 +79,7 @@ func TestConfiguredServiceWithTags(t *testing.T) {
 	}
 
 	cases := []testcase{
-		testcase{
+		{
 			conf: &SDConfig{
 				Services:    []string{"configuredServiceName"},
 				ServiceTags: []string{"http", "v1"},
@@ -88,7 +88,7 @@ func TestConfiguredServiceWithTags(t *testing.T) {
 			serviceTags: []string{""},
 			shouldWatch: false,
 		},
-		testcase{
+		{
 			conf: &SDConfig{
 				Services:    []string{"configuredServiceName"},
 				ServiceTags: []string{"http", "v1"},
@@ -97,7 +97,7 @@ func TestConfiguredServiceWithTags(t *testing.T) {
 			serviceTags: []string{"http", "v1"},
 			shouldWatch: true,
 		},
-		testcase{
+		{
 			conf: &SDConfig{
 				Services:    []string{"configuredServiceName"},
 				ServiceTags: []string{"http", "v1"},
@@ -106,7 +106,7 @@ func TestConfiguredServiceWithTags(t *testing.T) {
 			serviceTags: []string{""},
 			shouldWatch: false,
 		},
-		testcase{
+		{
 			conf: &SDConfig{
 				Services:    []string{"configuredServiceName"},
 				ServiceTags: []string{"http", "v1"},
@@ -115,7 +115,7 @@ func TestConfiguredServiceWithTags(t *testing.T) {
 			serviceTags: []string{"http, v1"},
 			shouldWatch: false,
 		},
-		testcase{
+		{
 			conf: &SDConfig{
 				Services:    []string{"configuredServiceName"},
 				ServiceTags: []string{"http", "v1"},
@@ -124,7 +124,7 @@ func TestConfiguredServiceWithTags(t *testing.T) {
 			serviceTags: []string{"http", "v1", "foo"},
 			shouldWatch: true,
 		},
-		testcase{
+		{
 			conf: &SDConfig{
 				Services:    []string{"configuredServiceName"},
 				ServiceTags: []string{"http", "v1", "foo"},
@@ -133,7 +133,7 @@ func TestConfiguredServiceWithTags(t *testing.T) {
 			serviceTags: []string{"http", "v1", "foo"},
 			shouldWatch: true,
 		},
-		testcase{
+		{
 			conf: &SDConfig{
 				Services:    []string{"configuredServiceName"},
 				ServiceTags: []string{"http", "v1"},
diff --git a/discovery/dns/dns_test.go b/discovery/dns/dns_test.go
index c7162085ec..8225ddf81c 100644
--- a/discovery/dns/dns_test.go
+++ b/discovery/dns/dns_test.go
@@ -66,7 +66,7 @@ func TestDNS(t *testing.T) {
 					nil
 			},
 			expected: []*targetgroup.Group{
-				&targetgroup.Group{
+				{
 					Source: "web.example.com.",
 					Targets: []model.LabelSet{
 						{"__address__": "192.0.2.2:80", "__meta_dns_name": "web.example.com."},
@@ -91,7 +91,7 @@ func TestDNS(t *testing.T) {
 					nil
 			},
 			expected: []*targetgroup.Group{
-				&targetgroup.Group{
+				{
 					Source: "web.example.com.",
 					Targets: []model.LabelSet{
 						{"__address__": "[::1]:80", "__meta_dns_name": "web.example.com."},
@@ -115,7 +115,7 @@ func TestDNS(t *testing.T) {
 					nil
 			},
 			expected: []*targetgroup.Group{
-				&targetgroup.Group{
+				{
 					Source: "_mysql._tcp.db.example.com.",
 					Targets: []model.LabelSet{
 						{"__address__": "db1.example.com:3306", "__meta_dns_name": "_mysql._tcp.db.example.com."},
@@ -140,7 +140,7 @@ func TestDNS(t *testing.T) {
 					nil
 			},
 			expected: []*targetgroup.Group{
-				&targetgroup.Group{
+				{
 					Source: "_mysql._tcp.db.example.com.",
 					Targets: []model.LabelSet{
 						{"__address__": "db1.example.com:3306", "__meta_dns_name": "_mysql._tcp.db.example.com."},
@@ -158,7 +158,7 @@ func TestDNS(t *testing.T) {
 				return &dns.Msg{}, nil
 			},
 			expected: []*targetgroup.Group{
-				&targetgroup.Group{
+				{
 					Source: "_mysql._tcp.db.example.com.",
 				},
 			},
diff --git a/docs/storage.md b/docs/storage.md
index d2df740393..e1831c37d2 100644
--- a/docs/storage.md
+++ b/docs/storage.md
@@ -45,7 +45,7 @@ The directory structure of a Prometheus server's data directory will look someth
 
 Note that a limitation of the local storage is that it is not clustered or replicated. Thus, it is not arbitrarily scalable or durable in the face of disk or node outages and should thus be treated as more of an ephemeral sliding window of recent data. However, if your durability requirements are not strict, you may still succeed in storing up to years of data in the local storage.
 
-For further details on file format, see [TSDB format](https://github.com/prometheus/tsdb/blob/master/docs/format/README.md).
+For further details on file format, see [TSDB format](https://github.com/prometheus/prometheus/blob/master/tsdb/docs/format/README.md).
 
 ## Compaction
 
diff --git a/documentation/internal_architecture.md b/documentation/internal_architecture.md
index 256e14bd1c..7cea388c5c 100644
--- a/documentation/internal_architecture.md
+++ b/documentation/internal_architecture.md
@@ -93,7 +93,7 @@ Currently rules still read and write directly from/to the fanout storage, but th
 
 ### Local storage
 
-Prometheus's local on-disk time series database is a [light-weight wrapper](https://github.com/prometheus/prometheus/blob/v2.3.1/storage/tsdb/tsdb.go#L102-L106) around [`github.com/prometheus/tsdb.DB`](https://github.com/prometheus/tsdb/blob/master/db.go#L92-L117). The wrapper makes only minor interface adjustments for use of the TSDB in the context of the Prometheus server and implements the [`storage.Storage` interface](https://github.com/prometheus/prometheus/blob/v2.3.1/storage/interface.go#L31-L44). You can find more details about the TSDB's on-disk layout in the [local storage documentation](https://prometheus.io/docs/prometheus/latest/storage/).
+Prometheus's local on-disk time series database is a [light-weight wrapper](https://github.com/prometheus/prometheus/blob/v2.3.1/storage/tsdb/tsdb.go#L102-L106) around [`github.com/prometheus/prometheus/tsdb.DB`](https://github.com/prometheus/prometheus/blob/master/tsdb/db.go#L92-L117). The wrapper makes only minor interface adjustments for use of the TSDB in the context of the Prometheus server and implements the [`storage.Storage` interface](https://github.com/prometheus/prometheus/blob/v2.3.1/storage/interface.go#L31-L44). You can find more details about the TSDB's on-disk layout in the [local storage documentation](https://prometheus.io/docs/prometheus/latest/storage/).
 
 ### Remote storage
 
diff --git a/go.mod b/go.mod
index cd8490651c..8bedeabf62 100644
--- a/go.mod
+++ b/go.mod
@@ -9,6 +9,7 @@ require (
 	github.com/aws/aws-sdk-go v1.15.24
 	github.com/cespare/xxhash v1.1.0
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible // indirect
+	github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954
 	github.com/edsrzf/mmap-go v1.0.0
 	github.com/evanphx/json-patch v4.1.0+incompatible // indirect
 	github.com/go-kit/kit v0.8.0
@@ -32,6 +33,7 @@ require (
 	github.com/miekg/dns v1.1.10
 	github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223
 	github.com/oklog/run v1.0.0
+	github.com/oklog/ulid v1.3.1
 	github.com/opentracing-contrib/go-stdlib v0.0.0-20170113013457-1de4cc2120e7
 	github.com/opentracing/opentracing-go v1.0.2
 	github.com/pkg/errors v0.8.1
@@ -39,7 +41,6 @@ require (
 	github.com/prometheus/client_golang v1.0.0
 	github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90
 	github.com/prometheus/common v0.4.1
-	github.com/prometheus/tsdb v0.10.0
 	github.com/samuel/go-zookeeper v0.0.0-20161028232340-1d7be4effb13
 	github.com/shurcooL/httpfs v0.0.0-20171119174359-809beceb2371
 	github.com/shurcooL/vfsgen v0.0.0-20180825020608-02ddb050ef6b
@@ -50,7 +51,8 @@ require (
 	golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c // indirect
 	golang.org/x/net v0.0.0-20190403144856-b630fd6fe46b
 	golang.org/x/oauth2 v0.0.0-20190402181905-9f3314589c9a
-	golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e // indirect
+	golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6
+	golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e
 	golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2
 	golang.org/x/tools v0.0.0-20190312170243-e65039ee4138
 	google.golang.org/api v0.3.2
diff --git a/go.sum b/go.sum
index da3b8e32aa..835d2f0fad 100644
--- a/go.sum
+++ b/go.sum
@@ -48,6 +48,7 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/dgrijalva/jwt-go v0.0.0-20160705203006-01aeca54ebda/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954 h1:RMLoZVzv4GliuWafOuPuQDKSm1SJph7uCRnnS61JAn4=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
 github.com/docker/go-units v0.3.3/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
 github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZgvJUkLughtfhJv5dyTYa91l1fOUCrgjqmcifM=
@@ -288,8 +289,6 @@ github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R
 github.com/prometheus/procfs v0.0.2 h1:6LJUbpNm42llc4HRCuvApCSWB/WfhuNo9K98Q9sNGfs=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/prometheus v0.0.0-20180315085919-58e2a31db8de/go.mod h1:oAIUtOny2rjMX0OWN5vPR5/q/twIROJvdqnQKDdil/s=
-github.com/prometheus/tsdb v0.10.0 h1:If5rVCMTp6W2SiRAQFlbpJNgVlgMEd+U2GZckwK38ic=
-github.com/prometheus/tsdb v0.10.0/go.mod h1:oi49uRhEe9dPUTlS3JRZOwJuVi6tmh10QSgwXEyGCt4=
 github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rs/cors v1.6.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
diff --git a/storage/remote/queue_manager.go b/storage/remote/queue_manager.go
index 7a1ce313a3..b476c68ad9 100644
--- a/storage/remote/queue_manager.go
+++ b/storage/remote/queue_manager.go
@@ -32,8 +32,8 @@ import (
 	"github.com/prometheus/prometheus/pkg/labels"
 	"github.com/prometheus/prometheus/pkg/relabel"
 	"github.com/prometheus/prometheus/prompb"
-	"github.com/prometheus/tsdb"
-	tsdbLabels "github.com/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb"
+	tsdbLabels "github.com/prometheus/prometheus/tsdb/labels"
 )
 
 // String constants for instrumentation.
@@ -253,7 +253,7 @@ outer:
 			ts := prompb.TimeSeries{
 				Labels: lbls,
 				Samples: []prompb.Sample{
-					prompb.Sample{
+					{
 						Value:     float64(sample.V),
 						Timestamp: sample.T,
 					},
diff --git a/storage/remote/queue_manager_test.go b/storage/remote/queue_manager_test.go
index 9e31982019..8d2a53249e 100644
--- a/storage/remote/queue_manager_test.go
+++ b/storage/remote/queue_manager_test.go
@@ -36,9 +36,9 @@ import (
 	"github.com/prometheus/prometheus/config"
 	"github.com/prometheus/prometheus/pkg/labels"
 	"github.com/prometheus/prometheus/prompb"
+	"github.com/prometheus/prometheus/tsdb"
+	tsdbLabels "github.com/prometheus/prometheus/tsdb/labels"
 	"github.com/prometheus/prometheus/util/testutil"
-	"github.com/prometheus/tsdb"
-	tsdbLabels "github.com/prometheus/tsdb/labels"
 )
 
 const defaultFlushDeadline = 1 * time.Minute
@@ -264,7 +264,7 @@ func TestReleaseNoninternedString(t *testing.T) {
 
 	for i := 1; i < 1000; i++ {
 		m.StoreSeries([]tsdb.RefSeries{
-			tsdb.RefSeries{
+			{
 				Ref: uint64(i),
 				Labels: tsdbLabels.Labels{
 					tsdbLabels.Label{
diff --git a/storage/remote/wal_watcher.go b/storage/remote/wal_watcher.go
index dbb7201fa0..f1b9056121 100644
--- a/storage/remote/wal_watcher.go
+++ b/storage/remote/wal_watcher.go
@@ -28,9 +28,9 @@ import (
 	"github.com/go-kit/kit/log/level"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/tsdb"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/wal"
+	"github.com/prometheus/prometheus/tsdb"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/wal"
 
 	"github.com/prometheus/prometheus/pkg/timestamp"
 )
diff --git a/storage/remote/wal_watcher_test.go b/storage/remote/wal_watcher_test.go
index a039a82605..dc2961c954 100644
--- a/storage/remote/wal_watcher_test.go
+++ b/storage/remote/wal_watcher_test.go
@@ -22,10 +22,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/prometheus/prometheus/tsdb"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/wal"
 	"github.com/prometheus/prometheus/util/testutil"
-	"github.com/prometheus/tsdb"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/wal"
 )
 
 var defaultRetryInterval = 100 * time.Millisecond
@@ -112,7 +112,7 @@ func TestTailSamples(t *testing.T) {
 			for i := 0; i < seriesCount; i++ {
 				ref := i + 100
 				series := enc.Series([]tsdb.RefSeries{
-					tsdb.RefSeries{
+					{
 						Ref:    uint64(ref),
 						Labels: labels.Labels{labels.Label{Name: "__name__", Value: fmt.Sprintf("metric_%d", i)}},
 					},
@@ -122,7 +122,7 @@ func TestTailSamples(t *testing.T) {
 				for j := 0; j < samplesCount; j++ {
 					inner := rand.Intn(ref + 1)
 					sample := enc.Samples([]tsdb.RefSample{
-						tsdb.RefSample{
+						{
 							Ref: uint64(inner),
 							T:   int64(now.UnixNano()) + 1,
 							V:   float64(i),
@@ -186,7 +186,7 @@ func TestReadToEndNoCheckpoint(t *testing.T) {
 
 			for i := 0; i < seriesCount; i++ {
 				series := enc.Series([]tsdb.RefSeries{
-					tsdb.RefSeries{
+					{
 						Ref:    uint64(i),
 						Labels: labels.Labels{labels.Label{Name: "__name__", Value: fmt.Sprintf("metric_%d", i)}},
 					},
@@ -194,7 +194,7 @@ func TestReadToEndNoCheckpoint(t *testing.T) {
 				recs = append(recs, series)
 				for j := 0; j < samplesCount; j++ {
 					sample := enc.Samples([]tsdb.RefSample{
-						tsdb.RefSample{
+						{
 							Ref: uint64(j),
 							T:   int64(i),
 							V:   float64(i),
@@ -254,7 +254,7 @@ func TestReadToEndWithCheckpoint(t *testing.T) {
 			for i := 0; i < seriesCount; i++ {
 				ref := i + 100
 				series := enc.Series([]tsdb.RefSeries{
-					tsdb.RefSeries{
+					{
 						Ref:    uint64(ref),
 						Labels: labels.Labels{labels.Label{Name: "__name__", Value: fmt.Sprintf("metric_%d", i)}},
 					},
@@ -264,7 +264,7 @@ func TestReadToEndWithCheckpoint(t *testing.T) {
 				for j := 0; j < samplesCount; j++ {
 					inner := rand.Intn(ref + 1)
 					sample := enc.Samples([]tsdb.RefSample{
-						tsdb.RefSample{
+						{
 							Ref: uint64(inner),
 							T:   int64(i),
 							V:   float64(i),
@@ -280,7 +280,7 @@ func TestReadToEndWithCheckpoint(t *testing.T) {
 			// Write more records after checkpointing.
 			for i := 0; i < seriesCount; i++ {
 				series := enc.Series([]tsdb.RefSeries{
-					tsdb.RefSeries{
+					{
 						Ref:    uint64(i),
 						Labels: labels.Labels{labels.Label{Name: "__name__", Value: fmt.Sprintf("metric_%d", i)}},
 					},
@@ -289,7 +289,7 @@ func TestReadToEndWithCheckpoint(t *testing.T) {
 
 				for j := 0; j < samplesCount; j++ {
 					sample := enc.Samples([]tsdb.RefSample{
-						tsdb.RefSample{
+						{
 							Ref: uint64(j),
 							T:   int64(i),
 							V:   float64(i),
@@ -340,7 +340,7 @@ func TestReadCheckpoint(t *testing.T) {
 			for i := 0; i < seriesCount; i++ {
 				ref := i + 100
 				series := enc.Series([]tsdb.RefSeries{
-					tsdb.RefSeries{
+					{
 						Ref:    uint64(ref),
 						Labels: labels.Labels{labels.Label{Name: "__name__", Value: fmt.Sprintf("metric_%d", i)}},
 					},
@@ -350,7 +350,7 @@ func TestReadCheckpoint(t *testing.T) {
 				for j := 0; j < samplesCount; j++ {
 					inner := rand.Intn(ref + 1)
 					sample := enc.Samples([]tsdb.RefSample{
-						tsdb.RefSample{
+						{
 							Ref: uint64(inner),
 							T:   int64(i),
 							V:   float64(i),
@@ -407,7 +407,7 @@ func TestReadCheckpointMultipleSegments(t *testing.T) {
 				for j := 0; j < seriesCount; j++ {
 					ref := j + (i * 100)
 					series := enc.Series([]tsdb.RefSeries{
-						tsdb.RefSeries{
+						{
 							Ref:    uint64(ref),
 							Labels: labels.Labels{labels.Label{Name: "__name__", Value: fmt.Sprintf("metric_%d", j)}},
 						},
@@ -417,7 +417,7 @@ func TestReadCheckpointMultipleSegments(t *testing.T) {
 					for k := 0; k < samplesCount; k++ {
 						inner := rand.Intn(ref + 1)
 						sample := enc.Samples([]tsdb.RefSample{
-							tsdb.RefSample{
+							{
 								Ref: uint64(inner),
 								T:   int64(i),
 								V:   float64(i),
@@ -485,7 +485,7 @@ func TestCheckpointSeriesReset(t *testing.T) {
 			for i := 0; i < seriesCount; i++ {
 				ref := i + 100
 				series := enc.Series([]tsdb.RefSeries{
-					tsdb.RefSeries{
+					{
 						Ref:    uint64(ref),
 						Labels: labels.Labels{labels.Label{Name: "__name__", Value: fmt.Sprintf("metric_%d", i)}},
 					},
@@ -495,7 +495,7 @@ func TestCheckpointSeriesReset(t *testing.T) {
 				for j := 0; j < samplesCount; j++ {
 					inner := rand.Intn(ref + 1)
 					sample := enc.Samples([]tsdb.RefSample{
-						tsdb.RefSample{
+						{
 							Ref: uint64(inner),
 							T:   int64(i),
 							V:   float64(i),
diff --git a/storage/tsdb/tsdb.go b/storage/tsdb/tsdb.go
index 42cb343536..e72242d126 100644
--- a/storage/tsdb/tsdb.go
+++ b/storage/tsdb/tsdb.go
@@ -26,8 +26,8 @@ import (
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/pkg/labels"
 	"github.com/prometheus/prometheus/storage"
-	"github.com/prometheus/tsdb"
-	tsdbLabels "github.com/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb"
+	tsdbLabels "github.com/prometheus/prometheus/tsdb/labels"
 )
 
 // ErrNotReady is returned if the underlying storage is not ready yet.
diff --git a/tsdb/.golangci.yml b/tsdb/.golangci.yml
deleted file mode 100644
index d9efa75c7c..0000000000
--- a/tsdb/.golangci.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-# Run only staticcheck for now. Additional linters will be enabled one-by-one.
-linters:
-  enable:
-  - staticcheck
-  disable-all: true
diff --git a/tsdb/.travis.yml b/tsdb/.travis.yml
deleted file mode 100644
index 6af68c3dee..0000000000
--- a/tsdb/.travis.yml
+++ /dev/null
@@ -1,20 +0,0 @@
-dist: trusty
-language: go
-os:
-  - windows
-  - linux
-  - osx
-
-go:
-  - 1.12.x
-
-go_import_path: github.com/prometheus/tsdb
-
-before_install:
-  - if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then choco install make; fi
-
-install:
-  - make deps
-
-script:
-  - if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then make test; else make all; fi
diff --git a/tsdb/LICENSE b/tsdb/LICENSE
deleted file mode 100644
index 261eeb9e9f..0000000000
--- a/tsdb/LICENSE
+++ /dev/null
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   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.
diff --git a/tsdb/Makefile b/tsdb/Makefile
deleted file mode 100644
index 7c35f8df2e..0000000000
--- a/tsdb/Makefile
+++ /dev/null
@@ -1,33 +0,0 @@
-# Copyright 2018 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.
-
-TSDB_PROJECT_DIR = "."
-TSDB_CLI_DIR="$(TSDB_PROJECT_DIR)/cmd/tsdb"
-TSDB_BIN = "$(TSDB_CLI_DIR)/tsdb"
-TSDB_BENCHMARK_NUM_METRICS ?= 1000
-TSDB_BENCHMARK_DATASET ?= "$(TSDB_PROJECT_DIR)/testdata/20kseries.json"
-TSDB_BENCHMARK_OUTPUT_DIR ?= "$(TSDB_CLI_DIR)/benchout"
-
-include Makefile.common
-
-build:
-	GO111MODULE=$(GO111MODULE) $(GO) build -o $(TSDB_BIN) $(TSDB_CLI_DIR)
-
-bench: build
-	@echo ">> running benchmark, writing result to $(TSDB_BENCHMARK_OUTPUT_DIR)"
-	@$(TSDB_BIN) bench write --metrics=$(TSDB_BENCHMARK_NUM_METRICS) --out=$(TSDB_BENCHMARK_OUTPUT_DIR) $(TSDB_BENCHMARK_DATASET)
-	@$(GO) tool pprof -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/cpu.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/cpuprof.svg
-	@$(GO) tool pprof --inuse_space -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/mem.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/memprof.inuse.svg
-	@$(GO) tool pprof --alloc_space -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/mem.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/memprof.alloc.svg
-	@$(GO) tool pprof -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/block.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/blockprof.svg
-	@$(GO) tool pprof -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/mutex.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/mutexprof.svg
diff --git a/tsdb/Makefile.common b/tsdb/Makefile.common
deleted file mode 100644
index db98993d69..0000000000
--- a/tsdb/Makefile.common
+++ /dev/null
@@ -1,277 +0,0 @@
-# Copyright 2018 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.
-
-
-# A common Makefile that includes rules to be reused in different prometheus projects.
-# !!! Open PRs only against the prometheus/prometheus/Makefile.common repository!
-
-# Example usage :
-# Create the main Makefile in the root project directory.
-# include Makefile.common
-# customTarget:
-# 	@echo ">> Running customTarget"
-#
-
-# Ensure GOBIN is not set during build so that promu is installed to the correct path
-unexport GOBIN
-
-GO           ?= go
-GOFMT        ?= $(GO)fmt
-FIRST_GOPATH := $(firstword $(subst :, ,$(shell $(GO) env GOPATH)))
-GOOPTS       ?=
-GOHOSTOS     ?= $(shell $(GO) env GOHOSTOS)
-GOHOSTARCH   ?= $(shell $(GO) env GOHOSTARCH)
-
-GO_VERSION        ?= $(shell $(GO) version)
-GO_VERSION_NUMBER ?= $(word 3, $(GO_VERSION))
-PRE_GO_111        ?= $(shell echo $(GO_VERSION_NUMBER) | grep -E 'go1\.(10|[0-9])\.')
-
-GOVENDOR :=
-GO111MODULE :=
-ifeq (, $(PRE_GO_111))
-	ifneq (,$(wildcard go.mod))
-		# Enforce Go modules support just in case the directory is inside GOPATH (and for Travis CI).
-		GO111MODULE := on
-
-		ifneq (,$(wildcard vendor))
-			# Always use the local vendor/ directory to satisfy the dependencies.
-			GOOPTS := $(GOOPTS) -mod=vendor
-		endif
-	endif
-else
-	ifneq (,$(wildcard go.mod))
-		ifneq (,$(wildcard vendor))
-$(warning This repository requires Go >= 1.11 because of Go modules)
-$(warning Some recipes may not work as expected as the current Go runtime is '$(GO_VERSION_NUMBER)')
-		endif
-	else
-		# This repository isn't using Go modules (yet).
-		GOVENDOR := $(FIRST_GOPATH)/bin/govendor
-	endif
-endif
-PROMU        := $(FIRST_GOPATH)/bin/promu
-pkgs          = ./...
-
-ifeq (arm, $(GOHOSTARCH))
-	GOHOSTARM ?= $(shell GOARM= $(GO) env GOARM)
-	GO_BUILD_PLATFORM ?= $(GOHOSTOS)-$(GOHOSTARCH)v$(GOHOSTARM)
-else
-	GO_BUILD_PLATFORM ?= $(GOHOSTOS)-$(GOHOSTARCH)
-endif
-
-PROMU_VERSION ?= 0.5.0
-PROMU_URL     := https://github.com/prometheus/promu/releases/download/v$(PROMU_VERSION)/promu-$(PROMU_VERSION).$(GO_BUILD_PLATFORM).tar.gz
-
-GOLANGCI_LINT :=
-GOLANGCI_LINT_OPTS ?=
-GOLANGCI_LINT_VERSION ?= v1.17.1
-# golangci-lint only supports linux, darwin and windows platforms on i386/amd64.
-# windows isn't included here because of the path separator being different.
-ifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux darwin))
-	ifeq ($(GOHOSTARCH),$(filter $(GOHOSTARCH),amd64 i386))
-		GOLANGCI_LINT := $(FIRST_GOPATH)/bin/golangci-lint
-	endif
-endif
-
-PREFIX                  ?= $(shell pwd)
-BIN_DIR                 ?= $(shell pwd)
-DOCKER_IMAGE_TAG        ?= $(subst /,-,$(shell git rev-parse --abbrev-ref HEAD))
-DOCKERFILE_PATH         ?= ./Dockerfile
-DOCKERBUILD_CONTEXT     ?= ./
-DOCKER_REPO             ?= prom
-
-DOCKER_ARCHS            ?= amd64
-
-BUILD_DOCKER_ARCHS = $(addprefix common-docker-,$(DOCKER_ARCHS))
-PUBLISH_DOCKER_ARCHS = $(addprefix common-docker-publish-,$(DOCKER_ARCHS))
-TAG_DOCKER_ARCHS = $(addprefix common-docker-tag-latest-,$(DOCKER_ARCHS))
-
-ifeq ($(GOHOSTARCH),amd64)
-        ifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux freebsd darwin windows))
-                # Only supported on amd64
-                test-flags := -race
-        endif
-endif
-
-# This rule is used to forward a target like "build" to "common-build".  This
-# allows a new "build" target to be defined in a Makefile which includes this
-# one and override "common-build" without override warnings.
-%: common-% ;
-
-.PHONY: common-all
-common-all: precheck style check_license lint unused build test
-
-.PHONY: common-style
-common-style:
-	@echo ">> checking code style"
-	@fmtRes=$$($(GOFMT) -d $$(find . -path ./vendor -prune -o -name '*.go' -print)); \
-	if [ -n "$${fmtRes}" ]; then \
-		echo "gofmt checking failed!"; echo "$${fmtRes}"; echo; \
-		echo "Please ensure you are using $$($(GO) version) for formatting code."; \
-		exit 1; \
-	fi
-
-.PHONY: common-check_license
-common-check_license:
-	@echo ">> checking license header"
-	@licRes=$$(for file in $$(find . -type f -iname '*.go' ! -path './vendor/*') ; do \
-               awk 'NR<=3' $$file | grep -Eq "(Copyright|generated|GENERATED)" || echo $$file; \
-       done); \
-       if [ -n "$${licRes}" ]; then \
-               echo "license header checking failed:"; echo "$${licRes}"; \
-               exit 1; \
-       fi
-
-.PHONY: common-deps
-common-deps:
-	@echo ">> getting dependencies"
-ifdef GO111MODULE
-	GO111MODULE=$(GO111MODULE) $(GO) mod download
-else
-	$(GO) get $(GOOPTS) -t ./...
-endif
-
-.PHONY: common-test-short
-common-test-short:
-	@echo ">> running short tests"
-	GO111MODULE=$(GO111MODULE) $(GO) test -short $(GOOPTS) $(pkgs)
-
-.PHONY: common-test
-common-test:
-	@echo ">> running all tests"
-	GO111MODULE=$(GO111MODULE) $(GO) test $(test-flags) $(GOOPTS) $(pkgs)
-
-.PHONY: common-format
-common-format:
-	@echo ">> formatting code"
-	GO111MODULE=$(GO111MODULE) $(GO) fmt $(pkgs)
-
-.PHONY: common-vet
-common-vet:
-	@echo ">> vetting code"
-	GO111MODULE=$(GO111MODULE) $(GO) vet $(GOOPTS) $(pkgs)
-
-.PHONY: common-lint
-common-lint: $(GOLANGCI_LINT)
-ifdef GOLANGCI_LINT
-	@echo ">> running golangci-lint"
-ifdef GO111MODULE
-# 'go list' needs to be executed before staticcheck to prepopulate the modules cache.
-# Otherwise staticcheck might fail randomly for some reason not yet explained.
-	GO111MODULE=$(GO111MODULE) $(GO) list -e -compiled -test=true -export=false -deps=true -find=false -tags= -- ./... > /dev/null
-	GO111MODULE=$(GO111MODULE) $(GOLANGCI_LINT) run $(GOLANGCI_LINT_OPTS) $(pkgs)
-else
-	$(GOLANGCI_LINT) run $(pkgs)
-endif
-endif
-
-# For backward-compatibility.
-.PHONY: common-staticcheck
-common-staticcheck: lint
-
-.PHONY: common-unused
-common-unused: $(GOVENDOR)
-ifdef GOVENDOR
-	@echo ">> running check for unused packages"
-	@$(GOVENDOR) list +unused | grep . && exit 1 || echo 'No unused packages'
-else
-ifdef GO111MODULE
-	@echo ">> running check for unused/missing packages in go.mod"
-	GO111MODULE=$(GO111MODULE) $(GO) mod tidy
-ifeq (,$(wildcard vendor))
-	@git diff --exit-code -- go.sum go.mod
-else
-	@echo ">> running check for unused packages in vendor/"
-	GO111MODULE=$(GO111MODULE) $(GO) mod vendor
-	@git diff --exit-code -- go.sum go.mod vendor/
-endif
-endif
-endif
-
-.PHONY: common-build
-common-build: promu
-	@echo ">> building binaries"
-	GO111MODULE=$(GO111MODULE) $(PROMU) build --prefix $(PREFIX)
-
-.PHONY: common-tarball
-common-tarball: promu
-	@echo ">> building release tarball"
-	$(PROMU) tarball --prefix $(PREFIX) $(BIN_DIR)
-
-.PHONY: common-docker $(BUILD_DOCKER_ARCHS)
-common-docker: $(BUILD_DOCKER_ARCHS)
-$(BUILD_DOCKER_ARCHS): common-docker-%:
-	docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)" \
-		-f $(DOCKERFILE_PATH) \
-		--build-arg ARCH="$*" \
-		--build-arg OS="linux" \
-		$(DOCKERBUILD_CONTEXT)
-
-.PHONY: common-docker-publish $(PUBLISH_DOCKER_ARCHS)
-common-docker-publish: $(PUBLISH_DOCKER_ARCHS)
-$(PUBLISH_DOCKER_ARCHS): common-docker-publish-%:
-	docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)"
-
-.PHONY: common-docker-tag-latest $(TAG_DOCKER_ARCHS)
-common-docker-tag-latest: $(TAG_DOCKER_ARCHS)
-$(TAG_DOCKER_ARCHS): common-docker-tag-latest-%:
-	docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:latest"
-
-.PHONY: common-docker-manifest
-common-docker-manifest:
-	DOCKER_CLI_EXPERIMENTAL=enabled docker manifest create -a "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" $(foreach ARCH,$(DOCKER_ARCHS),$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$(ARCH):$(DOCKER_IMAGE_TAG))
-	DOCKER_CLI_EXPERIMENTAL=enabled docker manifest push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)"
-
-.PHONY: promu
-promu: $(PROMU)
-
-$(PROMU):
-	$(eval PROMU_TMP := $(shell mktemp -d))
-	curl -s -L $(PROMU_URL) | tar -xvzf - -C $(PROMU_TMP)
-	mkdir -p $(FIRST_GOPATH)/bin
-	cp $(PROMU_TMP)/promu-$(PROMU_VERSION).$(GO_BUILD_PLATFORM)/promu $(FIRST_GOPATH)/bin/promu
-	rm -r $(PROMU_TMP)
-
-.PHONY: proto
-proto:
-	@echo ">> generating code from proto files"
-	@./scripts/genproto.sh
-
-ifdef GOLANGCI_LINT
-$(GOLANGCI_LINT):
-	mkdir -p $(FIRST_GOPATH)/bin
-	curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/$(GOLANGCI_LINT_VERSION)/install.sh \
-		| sed -e '/install -d/d' \
-		| sh -s -- -b $(FIRST_GOPATH)/bin $(GOLANGCI_LINT_VERSION)
-endif
-
-ifdef GOVENDOR
-.PHONY: $(GOVENDOR)
-$(GOVENDOR):
-	GOOS= GOARCH= $(GO) get -u github.com/kardianos/govendor
-endif
-
-.PHONY: precheck
-precheck::
-
-define PRECHECK_COMMAND_template =
-precheck:: $(1)_precheck
-
-PRECHECK_COMMAND_$(1) ?= $(1) $$(strip $$(PRECHECK_OPTIONS_$(1)))
-.PHONY: $(1)_precheck
-$(1)_precheck:
-	@if ! $$(PRECHECK_COMMAND_$(1)) 1>/dev/null 2>&1; then \
-		echo "Execution of '$$(PRECHECK_COMMAND_$(1))' command failed. Is $(1) installed?"; \
-		exit 1; \
-	fi
-endef
diff --git a/tsdb/block.go b/tsdb/block.go
index d0fe2b2f7f..b7771d6bbc 100644
--- a/tsdb/block.go
+++ b/tsdb/block.go
@@ -26,12 +26,12 @@ import (
 	"github.com/go-kit/kit/log/level"
 	"github.com/oklog/ulid"
 	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/chunkenc"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/index"
+	"github.com/prometheus/prometheus/tsdb/labels"
 )
 
 // IndexWriter serializes the index for a block of series data.
diff --git a/tsdb/block_test.go b/tsdb/block_test.go
index 3f39a899ed..e9389e99a4 100644
--- a/tsdb/block_test.go
+++ b/tsdb/block_test.go
@@ -26,10 +26,10 @@ import (
 	"testing"
 
 	"github.com/go-kit/kit/log"
-	"github.com/prometheus/tsdb/chunks"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/testutil"
-	"github.com/prometheus/tsdb/tsdbutil"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/tsdbutil"
 )
 
 // In Prometheus 2.1.0 we had a bug where the meta.json version was falsely bumped
diff --git a/tsdb/checkpoint.go b/tsdb/checkpoint.go
index eccfa62be3..d82e567f93 100644
--- a/tsdb/checkpoint.go
+++ b/tsdb/checkpoint.go
@@ -25,9 +25,9 @@ import (
 	"strings"
 
 	"github.com/pkg/errors"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/wal"
+	tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/wal"
 )
 
 // CheckpointStats returns stats about a created checkpoint.
diff --git a/tsdb/checkpoint_test.go b/tsdb/checkpoint_test.go
index 0779894b07..87753a79e8 100644
--- a/tsdb/checkpoint_test.go
+++ b/tsdb/checkpoint_test.go
@@ -23,10 +23,10 @@ import (
 	"testing"
 
 	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/testutil"
-	"github.com/prometheus/tsdb/wal"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/wal"
 )
 
 func TestLastCheckpoint(t *testing.T) {
diff --git a/tsdb/chunkenc/chunk_test.go b/tsdb/chunkenc/chunk_test.go
index f6577b429f..7205726038 100644
--- a/tsdb/chunkenc/chunk_test.go
+++ b/tsdb/chunkenc/chunk_test.go
@@ -20,7 +20,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 type pair struct {
diff --git a/tsdb/chunks/chunks.go b/tsdb/chunks/chunks.go
index 8c6945ca82..05ff7bc1b5 100644
--- a/tsdb/chunks/chunks.go
+++ b/tsdb/chunks/chunks.go
@@ -26,9 +26,9 @@ import (
 	"strconv"
 
 	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/chunkenc"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/chunkenc"
+	tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
 )
 
 const (
diff --git a/tsdb/chunks/chunks_test.go b/tsdb/chunks/chunks_test.go
index e153029b71..0454ea951b 100644
--- a/tsdb/chunks/chunks_test.go
+++ b/tsdb/chunks/chunks_test.go
@@ -16,7 +16,7 @@ package chunks
 import (
 	"testing"
 
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 func TestReaderWithInvalidBuffer(t *testing.T) {
diff --git a/tsdb/cmd/tsdb/main.go b/tsdb/cmd/tsdb/main.go
index e3dc530ae6..005adb2dd2 100644
--- a/tsdb/cmd/tsdb/main.go
+++ b/tsdb/cmd/tsdb/main.go
@@ -32,10 +32,10 @@ import (
 
 	"github.com/go-kit/kit/log"
 	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb"
-	"github.com/prometheus/tsdb/chunks"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
+	"github.com/prometheus/prometheus/tsdb/labels"
 	"gopkg.in/alecthomas/kingpin.v2"
 )
 
@@ -206,7 +206,9 @@ func (b *writeBenchmark) run() error {
 	var total uint64
 
 	dur, err := measureTime("ingestScrapes", func() error {
-		b.startProfiling()
+		if err := b.startProfiling(); err != nil {
+			return err
+		}
 		total, err = b.ingestScrapes(labels, 3000)
 		if err != nil {
 			return err
@@ -559,7 +561,7 @@ func analyzeBlock(b tsdb.BlockReader, limit int) error {
 		var cumulativeLength uint64
 
 		for i := 0; i < values.Len(); i++ {
-			value, _ := values.At(i)
+			value, err := values.At(i)
 			if err != nil {
 				return err
 			}
diff --git a/tsdb/compact.go b/tsdb/compact.go
index 9443c99e12..f88d27fba3 100644
--- a/tsdb/compact.go
+++ b/tsdb/compact.go
@@ -29,12 +29,12 @@ import (
 	"github.com/oklog/ulid"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/chunkenc"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/index"
+	"github.com/prometheus/prometheus/tsdb/labels"
 )
 
 // ExponentialBlockRanges returns the time ranges based on the stepSize.
diff --git a/tsdb/compact_test.go b/tsdb/compact_test.go
index 18990ed5e5..7f113b39a7 100644
--- a/tsdb/compact_test.go
+++ b/tsdb/compact_test.go
@@ -27,10 +27,10 @@ import (
 	"github.com/go-kit/kit/log"
 	"github.com/pkg/errors"
 	prom_testutil "github.com/prometheus/client_golang/prometheus/testutil"
-	"github.com/prometheus/tsdb/chunks"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 func TestSplitByRange(t *testing.T) {
@@ -651,7 +651,7 @@ func TestCompaction_populateBlock(t *testing.T) {
 			expErr:         errors.New("found chunk with minTime: 10 maxTime: 30 outside of compacted minTime: 0 maxTime: 20"),
 		},
 		{
-			// Introduced by https://github.com/prometheus/tsdb/issues/347.
+			// Introduced by https://github.com/prometheus/prometheus/tsdb/issues/347.
 			title: "Populate from single block containing extra chunk",
 			inputSeriesSamples: [][]seriesSamples{
 				{
@@ -691,7 +691,7 @@ func TestCompaction_populateBlock(t *testing.T) {
 			},
 		},
 		{
-			// Introduced by https://github.com/prometheus/tsdb/pull/539.
+			// Introduced by https://github.com/prometheus/prometheus/tsdb/pull/539.
 			title: "Populate from three blocks that the last two are overlapping.",
 			inputSeriesSamples: [][]seriesSamples{
 				{
diff --git a/tsdb/db.go b/tsdb/db.go
index ec830027c8..c80aa07043 100644
--- a/tsdb/db.go
+++ b/tsdb/db.go
@@ -34,12 +34,12 @@ import (
 	"github.com/oklog/ulid"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/tsdb/chunkenc"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-	_ "github.com/prometheus/tsdb/goversion"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/wal"
+	"github.com/prometheus/prometheus/tsdb/chunkenc"
+	tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
+	_ "github.com/prometheus/prometheus/tsdb/goversion"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/wal"
 	"golang.org/x/sync/errgroup"
 )
 
diff --git a/tsdb/db_test.go b/tsdb/db_test.go
index 25fb8a7e26..79c37d3356 100644
--- a/tsdb/db_test.go
+++ b/tsdb/db_test.go
@@ -30,12 +30,12 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	prom_testutil "github.com/prometheus/client_golang/prometheus/testutil"
-	"github.com/prometheus/tsdb/chunks"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/testutil"
-	"github.com/prometheus/tsdb/tsdbutil"
-	"github.com/prometheus/tsdb/wal"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	"github.com/prometheus/prometheus/tsdb/index"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/tsdbutil"
+	"github.com/prometheus/prometheus/tsdb/wal"
 )
 
 func openTestDB(t testing.TB, opts *Options) (db *DB, close func()) {
@@ -229,7 +229,7 @@ func TestAppendEmptyLabelsIgnored(t *testing.T) {
 	testutil.Ok(t, err)
 
 	// Construct labels manually so there is an empty label.
-	ref2, err := app1.Add(labels.Labels{labels.Label{"a", "b"}, labels.Label{"c", ""}}, 124, 0)
+	ref2, err := app1.Add(labels.Labels{labels.Label{Name: "a", Value: "b"}, labels.Label{Name: "c", Value: ""}}, 124, 0)
 	testutil.Ok(t, err)
 
 	// Should be the same series.
@@ -281,7 +281,7 @@ Outer:
 		smpls := make([]float64, numSamples)
 		for i := int64(0); i < numSamples; i++ {
 			smpls[i] = rand.Float64()
-			app.Add(labels.Labels{{"a", "b"}}, i, smpls[i])
+			app.Add(labels.Labels{{Name: "a", Value: "b"}}, i, smpls[i])
 		}
 
 		testutil.Ok(t, app.Commit())
@@ -405,9 +405,9 @@ func TestSkippingInvalidValuesInSameTxn(t *testing.T) {
 
 	// Append AmendedValue.
 	app := db.Appender()
-	_, err := app.Add(labels.Labels{{"a", "b"}}, 0, 1)
+	_, err := app.Add(labels.Labels{{Name: "a", Value: "b"}}, 0, 1)
 	testutil.Ok(t, err)
-	_, err = app.Add(labels.Labels{{"a", "b"}}, 0, 2)
+	_, err = app.Add(labels.Labels{{Name: "a", Value: "b"}}, 0, 2)
 	testutil.Ok(t, err)
 	testutil.Ok(t, app.Commit())
 
@@ -418,14 +418,14 @@ func TestSkippingInvalidValuesInSameTxn(t *testing.T) {
 	ssMap := query(t, q, labels.NewEqualMatcher("a", "b"))
 
 	testutil.Equals(t, map[string][]tsdbutil.Sample{
-		labels.New(labels.Label{"a", "b"}).String(): {sample{0, 1}},
+		labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 1}},
 	}, ssMap)
 
 	// Append Out of Order Value.
 	app = db.Appender()
-	_, err = app.Add(labels.Labels{{"a", "b"}}, 10, 3)
+	_, err = app.Add(labels.Labels{{Name: "a", Value: "b"}}, 10, 3)
 	testutil.Ok(t, err)
-	_, err = app.Add(labels.Labels{{"a", "b"}}, 7, 5)
+	_, err = app.Add(labels.Labels{{Name: "a", Value: "b"}}, 7, 5)
 	testutil.Ok(t, err)
 	testutil.Ok(t, app.Commit())
 
@@ -435,7 +435,7 @@ func TestSkippingInvalidValuesInSameTxn(t *testing.T) {
 	ssMap = query(t, q, labels.NewEqualMatcher("a", "b"))
 
 	testutil.Equals(t, map[string][]tsdbutil.Sample{
-		labels.New(labels.Label{"a", "b"}).String(): {sample{0, 1}, sample{10, 3}},
+		labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 1}, sample{10, 3}},
 	}, ssMap)
 }
 
@@ -556,7 +556,7 @@ func TestDB_SnapshotWithDelete(t *testing.T) {
 	smpls := make([]float64, numSamples)
 	for i := int64(0); i < numSamples; i++ {
 		smpls[i] = rand.Float64()
-		app.Add(labels.Labels{{"a", "b"}}, i, smpls[i])
+		app.Add(labels.Labels{{Name: "a", Value: "b"}}, i, smpls[i])
 	}
 
 	testutil.Ok(t, app.Commit())
@@ -645,44 +645,44 @@ func TestDB_e2e(t *testing.T) {
 	// Create 8 series with 1000 data-points of different ranges and run queries.
 	lbls := [][]labels.Label{
 		{
-			{"a", "b"},
-			{"instance", "localhost:9090"},
-			{"job", "prometheus"},
+			{Name: "a", Value: "b"},
+			{Name: "instance", Value: "localhost:9090"},
+			{Name: "job", Value: "prometheus"},
 		},
 		{
-			{"a", "b"},
-			{"instance", "127.0.0.1:9090"},
-			{"job", "prometheus"},
+			{Name: "a", Value: "b"},
+			{Name: "instance", Value: "127.0.0.1:9090"},
+			{Name: "job", Value: "prometheus"},
 		},
 		{
-			{"a", "b"},
-			{"instance", "127.0.0.1:9090"},
-			{"job", "prom-k8s"},
+			{Name: "a", Value: "b"},
+			{Name: "instance", Value: "127.0.0.1:9090"},
+			{Name: "job", Value: "prom-k8s"},
 		},
 		{
-			{"a", "b"},
-			{"instance", "localhost:9090"},
-			{"job", "prom-k8s"},
+			{Name: "a", Value: "b"},
+			{Name: "instance", Value: "localhost:9090"},
+			{Name: "job", Value: "prom-k8s"},
 		},
 		{
-			{"a", "c"},
-			{"instance", "localhost:9090"},
-			{"job", "prometheus"},
+			{Name: "a", Value: "c"},
+			{Name: "instance", Value: "localhost:9090"},
+			{Name: "job", Value: "prometheus"},
 		},
 		{
-			{"a", "c"},
-			{"instance", "127.0.0.1:9090"},
-			{"job", "prometheus"},
+			{Name: "a", Value: "c"},
+			{Name: "instance", Value: "127.0.0.1:9090"},
+			{Name: "job", Value: "prometheus"},
 		},
 		{
-			{"a", "c"},
-			{"instance", "127.0.0.1:9090"},
-			{"job", "prom-k8s"},
+			{Name: "a", Value: "c"},
+			{Name: "instance", Value: "127.0.0.1:9090"},
+			{Name: "job", Value: "prom-k8s"},
 		},
 		{
-			{"a", "c"},
-			{"instance", "localhost:9090"},
-			{"job", "prom-k8s"},
+			{Name: "a", Value: "c"},
+			{Name: "instance", Value: "localhost:9090"},
+			{Name: "job", Value: "prom-k8s"},
 		},
 	}
 
@@ -883,7 +883,7 @@ func TestTombstoneClean(t *testing.T) {
 	smpls := make([]float64, numSamples)
 	for i := int64(0); i < numSamples; i++ {
 		smpls[i] = rand.Float64()
-		app.Add(labels.Labels{{"a", "b"}}, i, smpls[i])
+		app.Add(labels.Labels{{Name: "a", Value: "b"}}, i, smpls[i])
 	}
 
 	testutil.Ok(t, app.Commit())
@@ -1339,7 +1339,7 @@ func TestOverlappingBlocksDetectsAllOverlaps(t *testing.T) {
 	}, OverlappingBlocks(nc1))
 }
 
-// Regression test for https://github.com/prometheus/tsdb/issues/347
+// Regression test for https://github.com/prometheus/prometheus/tsdb/issues/347
 func TestChunkAtBlockBoundary(t *testing.T) {
 	db, delete := openTestDB(t, nil)
 	defer func() {
@@ -1666,26 +1666,26 @@ func TestDB_LabelNames(t *testing.T) {
 	}{
 		{
 			sampleLabels1: [][2]string{
-				[2]string{"name1", "1"},
-				[2]string{"name3", "3"},
-				[2]string{"name2", "2"},
+				{"name1", "1"},
+				{"name3", "3"},
+				{"name2", "2"},
 			},
 			sampleLabels2: [][2]string{
-				[2]string{"name4", "4"},
-				[2]string{"name1", "1"},
+				{"name4", "4"},
+				{"name1", "1"},
 			},
 			exp1: []string{"name1", "name2", "name3"},
 			exp2: []string{"name1", "name2", "name3", "name4"},
 		},
 		{
 			sampleLabels1: [][2]string{
-				[2]string{"name2", "2"},
-				[2]string{"name1", "1"},
-				[2]string{"name2", "2"},
+				{"name2", "2"},
+				{"name1", "1"},
+				{"name2", "2"},
 			},
 			sampleLabels2: [][2]string{
-				[2]string{"name6", "6"},
-				[2]string{"name0", "0"},
+				{"name6", "6"},
+				{"name0", "0"},
 			},
 			exp1: []string{"name1", "name2"},
 			exp2: []string{"name0", "name1", "name2", "name6"},
@@ -1802,13 +1802,13 @@ func TestVerticalCompaction(t *testing.T) {
 		//        |----------------|
 		{
 			blockSeries: [][]Series{
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{0, 0}, sample{1, 0}, sample{2, 0}, sample{4, 0},
 						sample{5, 0}, sample{7, 0}, sample{8, 0}, sample{9, 0},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{3, 99}, sample{5, 99}, sample{6, 99}, sample{7, 99},
 						sample{8, 99}, sample{9, 99}, sample{10, 99}, sample{11, 99},
@@ -1830,14 +1830,14 @@ func TestVerticalCompaction(t *testing.T) {
 		//        |----------------|
 		{
 			blockSeries: [][]Series{
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{0, 0}, sample{1, 0}, sample{2, 0}, sample{4, 0},
 						sample{5, 0}, sample{7, 0}, sample{8, 0}, sample{9, 0},
 						sample{11, 0}, sample{13, 0}, sample{17, 0},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{3, 99}, sample{5, 99}, sample{6, 99}, sample{7, 99},
 						sample{8, 99}, sample{9, 99}, sample{10, 99},
@@ -1859,20 +1859,20 @@ func TestVerticalCompaction(t *testing.T) {
 		//                           |--------------------|
 		{
 			blockSeries: [][]Series{
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{0, 0}, sample{1, 0}, sample{2, 0}, sample{4, 0},
 						sample{5, 0}, sample{7, 0}, sample{8, 0}, sample{9, 0},
 						sample{11, 0}, sample{13, 0}, sample{17, 0},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{3, 99}, sample{5, 99}, sample{6, 99}, sample{7, 99},
 						sample{8, 99}, sample{9, 99},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{14, 59}, sample{15, 59}, sample{17, 59}, sample{20, 59},
 						sample{21, 59}, sample{22, 59},
@@ -1895,19 +1895,19 @@ func TestVerticalCompaction(t *testing.T) {
 		//               |----------------|
 		{
 			blockSeries: [][]Series{
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{0, 0}, sample{1, 0}, sample{2, 0}, sample{4, 0},
 						sample{5, 0}, sample{8, 0}, sample{9, 0},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{14, 59}, sample{15, 59}, sample{17, 59}, sample{20, 59},
 						sample{21, 59}, sample{22, 59},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{5, 99}, sample{6, 99}, sample{7, 99}, sample{8, 99},
 						sample{9, 99}, sample{10, 99}, sample{13, 99}, sample{15, 99},
@@ -1931,7 +1931,7 @@ func TestVerticalCompaction(t *testing.T) {
 		//      |-------------------------|
 		{
 			blockSeries: [][]Series{
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{0, 0}, sample{1, 0}, sample{2, 0}, sample{4, 0},
 						sample{5, 0}, sample{8, 0}, sample{9, 0}, sample{10, 0},
@@ -1939,13 +1939,13 @@ func TestVerticalCompaction(t *testing.T) {
 						sample{20, 0}, sample{22, 0},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{7, 59}, sample{8, 59}, sample{9, 59}, sample{10, 59},
 						sample{11, 59},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{3, 99}, sample{5, 99}, sample{6, 99}, sample{8, 99},
 						sample{9, 99}, sample{10, 99}, sample{13, 99}, sample{15, 99},
@@ -1969,7 +1969,7 @@ func TestVerticalCompaction(t *testing.T) {
 		//      |-------------------------|
 		{
 			blockSeries: [][]Series{
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{0, 0}, sample{1, 0}, sample{2, 0}, sample{4, 0},
 						sample{5, 0}, sample{8, 0}, sample{9, 0}, sample{10, 0},
@@ -1989,7 +1989,7 @@ func TestVerticalCompaction(t *testing.T) {
 						sample{20, 0}, sample{22, 0},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"__name__": "a"}, []tsdbutil.Sample{
 						sample{7, 59}, sample{8, 59}, sample{9, 59}, sample{10, 59},
 						sample{11, 59},
@@ -2007,7 +2007,7 @@ func TestVerticalCompaction(t *testing.T) {
 						sample{11, 59},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{3, 99}, sample{5, 99}, sample{6, 99}, sample{8, 99},
 						sample{9, 99}, sample{10, 99}, sample{13, 99}, sample{15, 99},
@@ -2066,26 +2066,26 @@ func TestVerticalCompaction(t *testing.T) {
 		//                                                  |----------------|
 		{
 			blockSeries: [][]Series{
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{0, 0}, sample{1, 0}, sample{2, 0}, sample{4, 0},
 						sample{5, 0}, sample{7, 0}, sample{8, 0}, sample{9, 0},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{3, 99}, sample{5, 99}, sample{6, 99}, sample{7, 99},
 						sample{8, 99}, sample{9, 99}, sample{10, 99}, sample{11, 99},
 						sample{12, 99}, sample{13, 99}, sample{14, 99},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{20, 0}, sample{21, 0}, sample{22, 0}, sample{24, 0},
 						sample{25, 0}, sample{27, 0}, sample{28, 0}, sample{29, 0},
 					}),
 				},
-				[]Series{
+				{
 					newSeries(map[string]string{"a": "b"}, []tsdbutil.Sample{
 						sample{23, 99}, sample{25, 99}, sample{26, 99}, sample{27, 99},
 						sample{28, 99}, sample{29, 99}, sample{30, 99}, sample{31, 99},
@@ -2186,7 +2186,7 @@ func TestBlockRanges(t *testing.T) {
 		os.RemoveAll(dir)
 	}()
 	app := db.Appender()
-	lbl := labels.Labels{{"a", "b"}}
+	lbl := labels.Labels{{Name: "a", Value: "b"}}
 	_, err = app.Add(lbl, firstBlockMaxT-1, rand.Float64())
 	if err == nil {
 		t.Fatalf("appending a sample with a timestamp covered by a previous block shouldn't be possible")
diff --git a/tsdb/fileutil/flock_test.go b/tsdb/fileutil/flock_test.go
index d30d20b21b..a5c880763c 100644
--- a/tsdb/fileutil/flock_test.go
+++ b/tsdb/fileutil/flock_test.go
@@ -18,7 +18,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 func TestLocking(t *testing.T) {
diff --git a/tsdb/go.mod b/tsdb/go.mod
deleted file mode 100644
index ccdd437247..0000000000
--- a/tsdb/go.mod
+++ /dev/null
@@ -1,14 +0,0 @@
-module github.com/prometheus/tsdb
-
-require (
-	github.com/cespare/xxhash v1.1.0
-	github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954
-	github.com/go-kit/kit v0.8.0
-	github.com/golang/snappy v0.0.1
-	github.com/oklog/ulid v1.3.1
-	github.com/pkg/errors v0.8.0
-	github.com/prometheus/client_golang v1.0.0
-	golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4
-	golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5
-	gopkg.in/alecthomas/kingpin.v2 v2.2.6
-)
diff --git a/tsdb/go.sum b/tsdb/go.sum
deleted file mode 100644
index 365fa5ecf4..0000000000
--- a/tsdb/go.sum
+++ /dev/null
@@ -1,83 +0,0 @@
-github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE=
-github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc h1:cAKDfWh5VpdgMhJosfJnn5/FoN2SRZ4p7fJNX58YPaU=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf h1:qet1QNfXsQxTZqLG4oE62mJzwPIB8+Tee4RNCL9ulrY=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973 h1:xJ4a3vCFaGF/jqvzLMYoU8P317H5OQ+Via4RmuPwCS0=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
-github.com/beorn7/perks v1.0.0 h1:HWo1m869IqiPhD389kmkxeTalrjNbbJTC8LXupb+sl0=
-github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
-github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
-github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954 h1:RMLoZVzv4GliuWafOuPuQDKSm1SJph7uCRnnS61JAn4=
-github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/go-kit/kit v0.8.0 h1:Wz+5lgoB0kkuqLEc6NVmwRknTKP6dTGbSqvhZtBI/j0=
-github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-logfmt/logfmt v0.3.0 h1:8HUsc87TaSWLKwrnumgC8/YconD2fJQsRJAsWaPg2ic=
-github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
-github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
-github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/gogo/protobuf v1.1.1 h1:72R+M5VuhED/KujmZVcIquuo8mBgX4oVda//DQb3PXo=
-github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
-github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 h1:T+h1c/A9Gawja4Y9mFVWj2vyii2bbUNDw3kt9VxK2EY=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
-github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
-github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/oklog/ulid v1.3.1 h1:EGfNDEx6MqHz8B3uNV6QAib1UR2Lm97sHi3ocA6ESJ4=
-github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
-github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v0.9.1 h1:K47Rk0v/fkEfwfQet2KWhscE0cJzjgCCDBG2KHZoVno=
-github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
-github.com/prometheus/client_golang v1.0.0 h1:vrDKnkGzuGvhNAL56c7DBz29ZL+KxnoR0x7enabFceM=
-github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910 h1:idejC8f05m9MGOsuEi1ATq9shN03HrxNkD/luQvxCv8=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
-github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90 h1:S/YWwWx/RA8rT8tKFRuGUZhuA90OyIBpPCXkcbwU8DE=
-github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/common v0.4.1 h1:K0MGApIoQvMw27RTdJkPbr3JZ7DNbtxQNyi5STVM6Kw=
-github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d h1:GoAlyOgbOEIFdaDqxJVlbOQ1DtGmZWs/Qau0hIlk+WQ=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/procfs v0.0.2 h1:6LJUbpNm42llc4HRCuvApCSWB/WfhuNo9K98Q9sNGfs=
-github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
-github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 h1:qLC7fQah7D6K1B0ujays3HV9gkFtllcxhzImRR7ArPQ=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4 h1:YUO/7uOKsKeq9UokNS62b8FYywz3ker1l1vDZRCRefw=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5 h1:mzjBh+S5frKOsOBobWIMAbXavqjmgO17k/2puhcFR94=
-golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-gopkg.in/alecthomas/kingpin.v2 v2.2.6 h1:jMFz6MfLP0/4fUyZle81rXUoxOBFi19VUFKVDOQfozc=
-gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/tsdb/goversion/goversio_test.go b/tsdb/goversion/goversio_test.go
index 9ed3c1165b..121e56e2ca 100644
--- a/tsdb/goversion/goversio_test.go
+++ b/tsdb/goversion/goversio_test.go
@@ -16,7 +16,7 @@ package goversion_test
 import (
 	"testing"
 
-	_ "github.com/prometheus/tsdb/goversion"
+	_ "github.com/prometheus/prometheus/tsdb/goversion"
 )
 
 // This test is is intentionally blank and exists only so `go test` believes
diff --git a/tsdb/head.go b/tsdb/head.go
index 0adb8847a9..219514ffe1 100644
--- a/tsdb/head.go
+++ b/tsdb/head.go
@@ -28,12 +28,12 @@ import (
 	"github.com/oklog/ulid"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
-	"github.com/prometheus/tsdb/encoding"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/wal"
+	"github.com/prometheus/prometheus/tsdb/chunkenc"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	"github.com/prometheus/prometheus/tsdb/encoding"
+	"github.com/prometheus/prometheus/tsdb/index"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/wal"
 )
 
 var (
diff --git a/tsdb/head_bench_test.go b/tsdb/head_bench_test.go
index 0b0391e0a9..f8c78cf8d0 100644
--- a/tsdb/head_bench_test.go
+++ b/tsdb/head_bench_test.go
@@ -18,8 +18,8 @@ import (
 	"sync/atomic"
 	"testing"
 
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 func BenchmarkHeadStripeSeriesCreate(b *testing.B) {
diff --git a/tsdb/head_test.go b/tsdb/head_test.go
index 040ae8289d..3551996e12 100644
--- a/tsdb/head_test.go
+++ b/tsdb/head_test.go
@@ -26,13 +26,13 @@ import (
 
 	"github.com/pkg/errors"
 	prom_testutil "github.com/prometheus/client_golang/prometheus/testutil"
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/testutil"
-	"github.com/prometheus/tsdb/tsdbutil"
-	"github.com/prometheus/tsdb/wal"
+	"github.com/prometheus/prometheus/tsdb/chunkenc"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	"github.com/prometheus/prometheus/tsdb/index"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/tsdbutil"
+	"github.com/prometheus/prometheus/tsdb/wal"
 )
 
 func BenchmarkCreateSeries(b *testing.B) {
@@ -368,7 +368,7 @@ func TestHeadDeleteSimple(t *testing.T) {
 		return ss
 	}
 	smplsAll := buildSmpls([]int64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
-	lblDefault := labels.Label{"a", "b"}
+	lblDefault := labels.Label{Name: "a", Value: "b"}
 
 	cases := []struct {
 		dranges  Intervals
@@ -536,7 +536,7 @@ func TestDeleteUntilCurMax(t *testing.T) {
 	smpls := make([]float64, numSamples)
 	for i := int64(0); i < numSamples; i++ {
 		smpls[i] = rand.Float64()
-		_, err := app.Add(labels.Labels{{"a", "b"}}, i, smpls[i])
+		_, err := app.Add(labels.Labels{{Name: "a", Value: "b"}}, i, smpls[i])
 		testutil.Ok(t, err)
 	}
 	testutil.Ok(t, app.Commit())
@@ -551,7 +551,7 @@ func TestDeleteUntilCurMax(t *testing.T) {
 
 	// Add again and test for presence.
 	app = hb.Appender()
-	_, err = app.Add(labels.Labels{{"a", "b"}}, 11, 1)
+	_, err = app.Add(labels.Labels{{Name: "a", Value: "b"}}, 11, 1)
 	testutil.Ok(t, err)
 	testutil.Ok(t, app.Commit())
 	q, err = NewBlockQuerier(hb, 0, 100000)
@@ -582,7 +582,7 @@ func TestDeletedSamplesAndSeriesStillInWALAfterCheckpoint(t *testing.T) {
 	defer hb.Close()
 	for i := 0; i < numSamples; i++ {
 		app := hb.Appender()
-		_, err := app.Add(labels.Labels{{"a", "b"}}, int64(i), 0)
+		_, err := app.Add(labels.Labels{{Name: "a", Value: "b"}}, int64(i), 0)
 		testutil.Ok(t, err)
 		testutil.Ok(t, app.Commit())
 	}
@@ -623,44 +623,44 @@ func TestDelete_e2e(t *testing.T) {
 	// Create 8 series with 1000 data-points of different ranges, delete and run queries.
 	lbls := [][]labels.Label{
 		{
-			{"a", "b"},
-			{"instance", "localhost:9090"},
-			{"job", "prometheus"},
+			{Name: "a", Value: "b"},
+			{Name: "instance", Value: "localhost:9090"},
+			{Name: "job", Value: "prometheus"},
 		},
 		{
-			{"a", "b"},
-			{"instance", "127.0.0.1:9090"},
-			{"job", "prometheus"},
+			{Name: "a", Value: "b"},
+			{Name: "instance", Value: "127.0.0.1:9090"},
+			{Name: "job", Value: "prometheus"},
 		},
 		{
-			{"a", "b"},
-			{"instance", "127.0.0.1:9090"},
-			{"job", "prom-k8s"},
+			{Name: "a", Value: "b"},
+			{Name: "instance", Value: "127.0.0.1:9090"},
+			{Name: "job", Value: "prom-k8s"},
 		},
 		{
-			{"a", "b"},
-			{"instance", "localhost:9090"},
-			{"job", "prom-k8s"},
+			{Name: "a", Value: "b"},
+			{Name: "instance", Value: "localhost:9090"},
+			{Name: "job", Value: "prom-k8s"},
 		},
 		{
-			{"a", "c"},
-			{"instance", "localhost:9090"},
-			{"job", "prometheus"},
+			{Name: "a", Value: "c"},
+			{Name: "instance", Value: "localhost:9090"},
+			{Name: "job", Value: "prometheus"},
 		},
 		{
-			{"a", "c"},
-			{"instance", "127.0.0.1:9090"},
-			{"job", "prometheus"},
+			{Name: "a", Value: "c"},
+			{Name: "instance", Value: "127.0.0.1:9090"},
+			{Name: "job", Value: "prometheus"},
 		},
 		{
-			{"a", "c"},
-			{"instance", "127.0.0.1:9090"},
-			{"job", "prom-k8s"},
+			{Name: "a", Value: "c"},
+			{Name: "instance", Value: "127.0.0.1:9090"},
+			{Name: "job", Value: "prom-k8s"},
 		},
 		{
-			{"a", "c"},
-			{"instance", "localhost:9090"},
-			{"job", "prom-k8s"},
+			{Name: "a", Value: "c"},
+			{Name: "instance", Value: "localhost:9090"},
+			{Name: "job", Value: "prom-k8s"},
 		},
 	}
 	seriesMap := map[string][]tsdbutil.Sample{}
@@ -1185,7 +1185,7 @@ func TestNewWalSegmentOnTruncate(t *testing.T) {
 	defer h.Close()
 	add := func(ts int64) {
 		app := h.Appender()
-		_, err := app.Add(labels.Labels{{"a", "b"}}, ts, 0)
+		_, err := app.Add(labels.Labels{{Name: "a", Value: "b"}}, ts, 0)
 		testutil.Ok(t, err)
 		testutil.Ok(t, app.Commit())
 	}
diff --git a/tsdb/index/index.go b/tsdb/index/index.go
index 1a1e9bf309..48ab96ba76 100644
--- a/tsdb/index/index.go
+++ b/tsdb/index/index.go
@@ -27,11 +27,11 @@ import (
 	"strings"
 
 	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/chunks"
-	"github.com/prometheus/tsdb/encoding"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	"github.com/prometheus/prometheus/tsdb/encoding"
+	tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/labels"
 )
 
 const (
diff --git a/tsdb/index/index_test.go b/tsdb/index/index_test.go
index 43b737c7d1..28622cc900 100644
--- a/tsdb/index/index_test.go
+++ b/tsdb/index/index_test.go
@@ -22,11 +22,11 @@ import (
 	"testing"
 
 	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
-	"github.com/prometheus/tsdb/encoding"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/chunkenc"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	"github.com/prometheus/prometheus/tsdb/encoding"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 type series struct {
diff --git a/tsdb/index/postings.go b/tsdb/index/postings.go
index cef2d886e0..6bc07eb3ec 100644
--- a/tsdb/index/postings.go
+++ b/tsdb/index/postings.go
@@ -21,7 +21,7 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/labels"
 )
 
 var allPostingsKey = labels.Label{}
diff --git a/tsdb/index/postings_test.go b/tsdb/index/postings_test.go
index 1eed1dbfb2..42dc6b3f35 100644
--- a/tsdb/index/postings_test.go
+++ b/tsdb/index/postings_test.go
@@ -20,7 +20,7 @@ import (
 	"sort"
 	"testing"
 
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 func TestMemPostings_addFor(t *testing.T) {
diff --git a/tsdb/labels/labels_test.go b/tsdb/labels/labels_test.go
index c49f66edf5..fbf63a0dee 100644
--- a/tsdb/labels/labels_test.go
+++ b/tsdb/labels/labels_test.go
@@ -20,7 +20,7 @@ import (
 	"sort"
 	"testing"
 
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 func TestCompareAndEquals(t *testing.T) {
diff --git a/tsdb/mocks_test.go b/tsdb/mocks_test.go
index 35f5ffecf3..e49c928684 100644
--- a/tsdb/mocks_test.go
+++ b/tsdb/mocks_test.go
@@ -14,10 +14,10 @@
 package tsdb
 
 import (
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/chunkenc"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	"github.com/prometheus/prometheus/tsdb/index"
+	"github.com/prometheus/prometheus/tsdb/labels"
 )
 
 type mockIndexWriter struct {
diff --git a/tsdb/querier.go b/tsdb/querier.go
index fbd9493f4f..aba0f4dd1d 100644
--- a/tsdb/querier.go
+++ b/tsdb/querier.go
@@ -20,11 +20,11 @@ import (
 	"unicode/utf8"
 
 	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/chunkenc"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
+	"github.com/prometheus/prometheus/tsdb/index"
+	"github.com/prometheus/prometheus/tsdb/labels"
 )
 
 // Querier provides querying access over time series data of a fixed
@@ -287,7 +287,7 @@ func findSetMatches(pattern string) []string {
 		return nil
 	}
 	escaped := false
-	sets := []*strings.Builder{&strings.Builder{}}
+	sets := []*strings.Builder{{}}
 	for i := 4; i < len(pattern)-2; i++ {
 		if escaped {
 			switch {
diff --git a/tsdb/querier_test.go b/tsdb/querier_test.go
index 2be48fcd5b..b9366ec4c3 100644
--- a/tsdb/querier_test.go
+++ b/tsdb/querier_test.go
@@ -25,12 +25,12 @@ import (
 	"testing"
 
 	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/testutil"
-	"github.com/prometheus/tsdb/tsdbutil"
+	"github.com/prometheus/prometheus/tsdb/chunkenc"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	"github.com/prometheus/prometheus/tsdb/index"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/tsdbutil"
 )
 
 type mockSeriesSet struct {
@@ -461,9 +461,9 @@ func TestBlockQuerierDelete(t *testing.T) {
 			},
 		},
 		tombstones: &memTombstones{intvlGroups: map[uint64]Intervals{
-			1: Intervals{{1, 3}},
-			2: Intervals{{1, 3}, {6, 10}},
-			3: Intervals{{6, 10}},
+			1: {{1, 3}},
+			2: {{1, 3}, {6, 10}},
+			3: {{6, 10}},
 		}},
 		queries: []query{
 			{
@@ -578,7 +578,7 @@ func TestBaseChunkSeries(t *testing.T) {
 		{
 			series: []refdSeries{
 				{
-					lset: labels.New([]labels.Label{{"a", "a"}}...),
+					lset: labels.New([]labels.Label{{Name: "a", Value: "a"}}...),
 					chunks: []chunks.Meta{
 						{Ref: 29}, {Ref: 45}, {Ref: 245}, {Ref: 123}, {Ref: 4232}, {Ref: 5344},
 						{Ref: 121},
@@ -586,19 +586,19 @@ func TestBaseChunkSeries(t *testing.T) {
 					ref: 12,
 				},
 				{
-					lset: labels.New([]labels.Label{{"a", "a"}, {"b", "b"}}...),
+					lset: labels.New([]labels.Label{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}}...),
 					chunks: []chunks.Meta{
 						{Ref: 82}, {Ref: 23}, {Ref: 234}, {Ref: 65}, {Ref: 26},
 					},
 					ref: 10,
 				},
 				{
-					lset:   labels.New([]labels.Label{{"b", "c"}}...),
+					lset:   labels.New([]labels.Label{{Name: "b", Value: "c"}}...),
 					chunks: []chunks.Meta{{Ref: 8282}},
 					ref:    1,
 				},
 				{
-					lset: labels.New([]labels.Label{{"b", "b"}}...),
+					lset: labels.New([]labels.Label{{Name: "b", Value: "b"}}...),
 					chunks: []chunks.Meta{
 						{Ref: 829}, {Ref: 239}, {Ref: 2349}, {Ref: 659}, {Ref: 269},
 					},
@@ -611,14 +611,14 @@ func TestBaseChunkSeries(t *testing.T) {
 		{
 			series: []refdSeries{
 				{
-					lset: labels.New([]labels.Label{{"a", "a"}, {"b", "b"}}...),
+					lset: labels.New([]labels.Label{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}}...),
 					chunks: []chunks.Meta{
 						{Ref: 82}, {Ref: 23}, {Ref: 234}, {Ref: 65}, {Ref: 26},
 					},
 					ref: 10,
 				},
 				{
-					lset:   labels.New([]labels.Label{{"b", "c"}}...),
+					lset:   labels.New([]labels.Label{{Name: "b", Value: "c"}}...),
 					chunks: []chunks.Meta{{Ref: 8282}},
 					ref:    3,
 				},
@@ -1044,7 +1044,7 @@ func TestSeriesIterator(t *testing.T) {
 	})
 }
 
-// Regression for: https://github.com/prometheus/tsdb/pull/97
+// Regression for: https://github.com/prometheus/prometheus/tsdb/pull/97
 func TestChunkSeriesIterator_DoubleSeek(t *testing.T) {
 	chkMetas := []chunks.Meta{
 		tsdbutil.ChunkFromSamples([]tsdbutil.Sample{}),
@@ -1094,7 +1094,7 @@ func TestChunkSeriesIterator_NextWithMinTime(t *testing.T) {
 }
 
 func TestPopulatedCSReturnsValidChunkSlice(t *testing.T) {
-	lbls := []labels.Labels{labels.New(labels.Label{"a", "b"})}
+	lbls := []labels.Labels{labels.New(labels.Label{Name: "a", Value: "b"})}
 	chunkMetas := [][]chunks.Meta{
 		{
 			{MinTime: 1, MaxTime: 2, Ref: 1},
@@ -2109,27 +2109,27 @@ func TestClose(t *testing.T) {
 
 func BenchmarkQueries(b *testing.B) {
 	cases := map[string]labels.Selector{
-		"Eq Matcher: Expansion - 1": labels.Selector{
+		"Eq Matcher: Expansion - 1": {
 			labels.NewEqualMatcher("la", "va"),
 		},
-		"Eq Matcher: Expansion - 2": labels.Selector{
+		"Eq Matcher: Expansion - 2": {
 			labels.NewEqualMatcher("la", "va"),
 			labels.NewEqualMatcher("lb", "vb"),
 		},
 
-		"Eq Matcher: Expansion - 3": labels.Selector{
+		"Eq Matcher: Expansion - 3": {
 			labels.NewEqualMatcher("la", "va"),
 			labels.NewEqualMatcher("lb", "vb"),
 			labels.NewEqualMatcher("lc", "vc"),
 		},
-		"Regex Matcher: Expansion - 1": labels.Selector{
+		"Regex Matcher: Expansion - 1": {
 			labels.NewMustRegexpMatcher("la", ".*va"),
 		},
-		"Regex Matcher: Expansion - 2": labels.Selector{
+		"Regex Matcher: Expansion - 2": {
 			labels.NewMustRegexpMatcher("la", ".*va"),
 			labels.NewMustRegexpMatcher("lb", ".*vb"),
 		},
-		"Regex Matcher: Expansion - 3": labels.Selector{
+		"Regex Matcher: Expansion - 3": {
 			labels.NewMustRegexpMatcher("la", ".*va"),
 			labels.NewMustRegexpMatcher("lb", ".*vb"),
 			labels.NewMustRegexpMatcher("lc", ".*vc"),
diff --git a/tsdb/record.go b/tsdb/record.go
index 8d9c5751da..174d3bd14f 100644
--- a/tsdb/record.go
+++ b/tsdb/record.go
@@ -19,8 +19,8 @@ import (
 	"sort"
 
 	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/encoding"
-	"github.com/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/encoding"
+	"github.com/prometheus/prometheus/tsdb/labels"
 )
 
 // RecordType represents the data type of a record.
diff --git a/tsdb/record_test.go b/tsdb/record_test.go
index 8316ccf3ab..7d948c7f4e 100644
--- a/tsdb/record_test.go
+++ b/tsdb/record_test.go
@@ -18,9 +18,9 @@ import (
 	"testing"
 
 	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/encoding"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/encoding"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 func TestRecord_EncodeDecode(t *testing.T) {
diff --git a/tsdb/repair.go b/tsdb/repair.go
index 1d299047a0..494f005e42 100644
--- a/tsdb/repair.go
+++ b/tsdb/repair.go
@@ -23,8 +23,8 @@ import (
 	"github.com/go-kit/kit/log"
 	"github.com/go-kit/kit/log/level"
 	"github.com/pkg/errors"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
+	tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
 )
 
 // repairBadIndexVersion repairs an issue in index and meta.json persistence introduced in
diff --git a/tsdb/repair_test.go b/tsdb/repair_test.go
index 1d6345cd16..3cb5d43ded 100644
--- a/tsdb/repair_test.go
+++ b/tsdb/repair_test.go
@@ -18,11 +18,11 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/prometheus/tsdb/chunks"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/chunks"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/index"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 func TestRepairBadIndexVersion(t *testing.T) {
@@ -117,8 +117,8 @@ func TestRepairBadIndexVersion(t *testing.T) {
 
 	testutil.Ok(t, p.Err())
 	testutil.Equals(t, []labels.Labels{
-		{{"a", "1"}, {"b", "1"}},
-		{{"a", "2"}, {"b", "1"}},
+		{{Name: "a", Value: "1"}, {Name: "b", Value: "1"}},
+		{{Name: "a", Value: "2"}, {Name: "b", Value: "1"}},
 	}, res)
 
 	meta, _, err := readMetaFile(tmpDbDir)
diff --git a/tsdb/test/labels_test.go b/tsdb/test/labels_test.go
index 2a454b867d..c8a246c228 100644
--- a/tsdb/test/labels_test.go
+++ b/tsdb/test/labels_test.go
@@ -18,7 +18,7 @@ import (
 	"crypto/rand"
 	"testing"
 
-	"github.com/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/labels"
 )
 
 func BenchmarkMapClone(b *testing.B) {
diff --git a/tsdb/tombstones.go b/tsdb/tombstones.go
index d7b76230c0..8910f7b8b3 100644
--- a/tsdb/tombstones.go
+++ b/tsdb/tombstones.go
@@ -25,9 +25,9 @@ import (
 	"github.com/go-kit/kit/log"
 	"github.com/go-kit/kit/log/level"
 	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/encoding"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/encoding"
+	tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
 )
 
 const tombstoneFilename = "tombstones"
diff --git a/tsdb/tombstones_test.go b/tsdb/tombstones_test.go
index 33ebb3bccc..947aa98bf6 100644
--- a/tsdb/tombstones_test.go
+++ b/tsdb/tombstones_test.go
@@ -22,7 +22,7 @@ import (
 	"time"
 
 	"github.com/go-kit/kit/log"
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 func TestWriteAndReadbackTombStones(t *testing.T) {
diff --git a/tsdb/tsdbutil/buffer_test.go b/tsdb/tsdbutil/buffer_test.go
index 0e3b8d045e..7323a9e7d8 100644
--- a/tsdb/tsdbutil/buffer_test.go
+++ b/tsdb/tsdbutil/buffer_test.go
@@ -18,7 +18,7 @@ import (
 	"sort"
 	"testing"
 
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 func TestSampleRing(t *testing.T) {
diff --git a/tsdb/tsdbutil/chunks.go b/tsdb/tsdbutil/chunks.go
index e14d951ba2..8acaae9b57 100644
--- a/tsdb/tsdbutil/chunks.go
+++ b/tsdb/tsdbutil/chunks.go
@@ -14,8 +14,8 @@
 package tsdbutil
 
 import (
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
+	"github.com/prometheus/prometheus/tsdb/chunkenc"
+	"github.com/prometheus/prometheus/tsdb/chunks"
 )
 
 type Sample interface {
diff --git a/tsdb/wal.go b/tsdb/wal.go
index 49f55fe404..4809889f32 100644
--- a/tsdb/wal.go
+++ b/tsdb/wal.go
@@ -31,10 +31,10 @@ import (
 	"github.com/go-kit/kit/log/level"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/tsdb/encoding"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/wal"
+	"github.com/prometheus/prometheus/tsdb/encoding"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/wal"
 )
 
 // WALEntryType indicates what data a WAL entry contains.
@@ -392,10 +392,14 @@ func (w *SegmentWAL) Truncate(mint int64, keep func(uint64) bool) error {
 	if err := csf.Truncate(off); err != nil {
 		return err
 	}
-	csf.Sync()
-	csf.Close()
+	if err := csf.Sync(); err != nil {
+		return nil
+	}
+	if err := csf.Close(); err != nil {
+		return nil
+	}
 
-	candidates[0].Close() // need close before remove on platform windows
+	_ = candidates[0].Close() // need close before remove on platform windows
 	if err := fileutil.Replace(csf.Name(), candidates[0].Name()); err != nil {
 		return errors.Wrap(err, "rename compaction segment")
 	}
@@ -416,7 +420,9 @@ func (w *SegmentWAL) Truncate(mint int64, keep func(uint64) bool) error {
 		return err
 	}
 	// We don't need it to be open.
-	csf.Close()
+	if err := csf.Close(); err != nil {
+		return err
+	}
 
 	w.mtx.Lock()
 	w.files = append([]*segmentFile{csf}, w.files[len(candidates):]...)
diff --git a/tsdb/wal/live_reader.go b/tsdb/wal/live_reader.go
index 94175e7917..6d29036884 100644
--- a/tsdb/wal/live_reader.go
+++ b/tsdb/wal/live_reader.go
@@ -32,7 +32,7 @@ type liveReaderMetrics struct {
 	readerCorruptionErrors *prometheus.CounterVec
 }
 
-// LiveReaderMetrics instatiates, registers and returns metrics to be injected
+// NewLiveReaderMetrics instatiates, registers and returns metrics to be injected
 // at LiveReader instantiation.
 func NewLiveReaderMetrics(reg prometheus.Registerer) *liveReaderMetrics {
 	m := &liveReaderMetrics{
@@ -43,7 +43,8 @@ func NewLiveReaderMetrics(reg prometheus.Registerer) *liveReaderMetrics {
 	}
 
 	if reg != nil {
-		reg.Register(m.readerCorruptionErrors)
+		// TODO(codesome): log error.
+		_ = reg.Register(m.readerCorruptionErrors)
 	}
 
 	return m
diff --git a/tsdb/wal/reader_test.go b/tsdb/wal/reader_test.go
index 96d1522540..d9c74453a4 100644
--- a/tsdb/wal/reader_test.go
+++ b/tsdb/wal/reader_test.go
@@ -30,8 +30,8 @@ import (
 	"time"
 
 	"github.com/go-kit/kit/log"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/testutil"
+	tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 type reader interface {
diff --git a/tsdb/wal/wal.go b/tsdb/wal/wal.go
index 75d6dc3d22..82081e321a 100644
--- a/tsdb/wal/wal.go
+++ b/tsdb/wal/wal.go
@@ -32,7 +32,7 @@ import (
 	"github.com/golang/snappy"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
 )
 
 const (
@@ -387,7 +387,9 @@ func (w *WAL) Repair(origErr error) error {
 	// We expect an error here from r.Err(), so nothing to handle.
 
 	// We need to pad to the end of the last page in the repaired segment
-	w.flushPage(true)
+	if err := w.flushPage(true); err != nil {
+		return errors.Wrap(err, "flush page in repair")
+	}
 
 	// We explicitly close even when there is a defer for Windows to be
 	// able to delete it. The defer is in place to close it in-case there
diff --git a/tsdb/wal/wal_test.go b/tsdb/wal/wal_test.go
index 12fe1a2d76..d99a96342e 100644
--- a/tsdb/wal/wal_test.go
+++ b/tsdb/wal/wal_test.go
@@ -24,7 +24,7 @@ import (
 	"testing"
 
 	client_testutil "github.com/prometheus/client_golang/prometheus/testutil"
-	"github.com/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/testutil"
 )
 
 // TestWALRepair_ReadingError ensures that a repair is run for an error
@@ -47,7 +47,7 @@ func TestWALRepair_ReadingError(t *testing.T) {
 		},
 		// Ensures that the page buffer is big enough to fit
 		// an entire page size without panicing.
-		// https://github.com/prometheus/tsdb/pull/414
+		// https://github.com/prometheus/prometheus/tsdb/pull/414
 		"bad_header": {
 			1,
 			func(f *os.File) {
diff --git a/tsdb/wal_test.go b/tsdb/wal_test.go
index 0fed5b415b..5c8a7489d5 100644
--- a/tsdb/wal_test.go
+++ b/tsdb/wal_test.go
@@ -27,10 +27,10 @@ import (
 	"time"
 
 	"github.com/go-kit/kit/log"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/testutil"
-	"github.com/prometheus/tsdb/wal"
+	"github.com/prometheus/prometheus/tsdb/fileutil"
+	"github.com/prometheus/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb/testutil"
+	"github.com/prometheus/prometheus/tsdb/wal"
 )
 
 func TestSegmentWAL_cut(t *testing.T) {
diff --git a/vendor/github.com/dgryski/go-sip13/LICENSE b/vendor/github.com/dgryski/go-sip13/LICENSE
new file mode 100644
index 0000000000..315b080c12
--- /dev/null
+++ b/vendor/github.com/dgryski/go-sip13/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016,2017 Damian Gryski <damian@gryski.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/dgryski/go-sip13/sip13.go b/vendor/github.com/dgryski/go-sip13/sip13.go
new file mode 100644
index 0000000000..b01bd7fd1b
--- /dev/null
+++ b/vendor/github.com/dgryski/go-sip13/sip13.go
@@ -0,0 +1,88 @@
+// +build !amd64 noasm
+
+package sip13
+
+import (
+	"encoding/binary"
+	"math/bits"
+)
+
+type sip struct {
+	v0, v1, v2, v3 uint64
+}
+
+func (s *sip) round() {
+	s.v0 += s.v1
+	s.v2 += s.v3
+	s.v1 = bits.RotateLeft64(s.v1, 13)
+	s.v3 = bits.RotateLeft64(s.v3, 16)
+	s.v1 ^= s.v0
+	s.v3 ^= s.v2
+	s.v0 = bits.RotateLeft64(s.v0, 32)
+	s.v2 += s.v1
+	s.v0 += s.v3
+	s.v1 = bits.RotateLeft64(s.v1, 17)
+	s.v3 = bits.RotateLeft64(s.v3, 21)
+	s.v1 ^= s.v2
+	s.v3 ^= s.v0
+	s.v2 = bits.RotateLeft64(s.v2, 32)
+}
+
+func Sum64Str(k0, k1 uint64, p string) uint64 {
+	return Sum64(k0, k1, []byte(p))
+}
+
+func Sum64(k0, k1 uint64, p []byte) uint64 {
+
+	s := sip{
+		v0: k0 ^ 0x736f6d6570736575,
+		v1: k1 ^ 0x646f72616e646f6d,
+		v2: k0 ^ 0x6c7967656e657261,
+		v3: k1 ^ 0x7465646279746573,
+	}
+	b := uint64(len(p)) << 56
+
+	for len(p) >= 8 {
+		m := binary.LittleEndian.Uint64(p[:8])
+		s.v3 ^= m
+		s.round()
+		s.v0 ^= m
+		p = p[8:]
+	}
+
+	switch len(p) {
+	case 7:
+		b |= uint64(p[6]) << 48
+		fallthrough
+	case 6:
+		b |= uint64(p[5]) << 40
+		fallthrough
+	case 5:
+		b |= uint64(p[4]) << 32
+		fallthrough
+	case 4:
+		b |= uint64(p[3]) << 24
+		fallthrough
+	case 3:
+		b |= uint64(p[2]) << 16
+		fallthrough
+	case 2:
+		b |= uint64(p[1]) << 8
+		fallthrough
+	case 1:
+		b |= uint64(p[0])
+	}
+
+	// last block
+	s.v3 ^= b
+	s.round()
+	s.v0 ^= b
+
+	// finalization
+	s.v2 ^= 0xff
+	s.round()
+	s.round()
+	s.round()
+
+	return s.v0 ^ s.v1 ^ s.v2 ^ s.v3
+}
diff --git a/vendor/github.com/dgryski/go-sip13/sip13.py b/vendor/github.com/dgryski/go-sip13/sip13.py
new file mode 100644
index 0000000000..6c302fbcef
--- /dev/null
+++ b/vendor/github.com/dgryski/go-sip13/sip13.py
@@ -0,0 +1,119 @@
+import peachpy.x86_64
+
+k0 = Argument(uint64_t)
+k1 = Argument(uint64_t)
+p_base = Argument(ptr())
+p_len = Argument(int64_t)
+p_cap = Argument(int64_t)
+
+# siphash 1-3
+cROUND = 1
+dROUND = 3
+
+
+def sipround(v0, v1, v2, v3):
+    ADD(v0, v1)
+    ADD(v2, v3)
+    ROL(v1, 13)
+    ROL(v3, 16)
+    XOR(v1, v0)
+    XOR(v3, v2)
+
+    ROL(v0, 32)
+
+    ADD(v2, v1)
+    ADD(v0, v3)
+    ROL(v1, 17)
+    ROL(v3, 21)
+    XOR(v1, v2)
+    XOR(v3, v0)
+
+    ROL(v2, 32)
+
+
+def makeSip(name, args):
+
+    with Function(name, args, uint64_t, target=uarch.default) as function:
+
+        reg_v0 = GeneralPurposeRegister64()
+        reg_v1 = GeneralPurposeRegister64()
+        reg_v2 = GeneralPurposeRegister64()
+        reg_v3 = GeneralPurposeRegister64()
+
+        LOAD.ARGUMENT(reg_v0, k0)
+        MOV(reg_v2, reg_v0)
+        LOAD.ARGUMENT(reg_v1, k1)
+        MOV(reg_v3, reg_v1)
+
+        reg_magic = GeneralPurposeRegister64()
+        MOV(reg_magic, 0x736f6d6570736575)
+        XOR(reg_v0, reg_magic)
+        MOV(reg_magic, 0x646f72616e646f6d)
+        XOR(reg_v1, reg_magic)
+        MOV(reg_magic, 0x6c7967656e657261)
+        XOR(reg_v2, reg_magic)
+        MOV(reg_magic, 0x7465646279746573)
+        XOR(reg_v3, reg_magic)
+
+        reg_p = GeneralPurposeRegister64()
+        reg_p_len = GeneralPurposeRegister64()
+        LOAD.ARGUMENT(reg_p, p_base)
+        LOAD.ARGUMENT(reg_p_len, p_len)
+
+        reg_b = GeneralPurposeRegister64()
+        MOV(reg_b, reg_p_len)
+        SHL(reg_b, 56)
+
+        reg_m = GeneralPurposeRegister64()
+
+        loop = Loop()
+
+        CMP(reg_p_len, 8)
+        JL(loop.end)
+        with loop:
+            MOV(reg_m, [reg_p])
+
+            XOR(reg_v3, reg_m)
+            for _ in range(0, cROUND):
+                sipround(reg_v0, reg_v1, reg_v2, reg_v3)
+            XOR(reg_v0, reg_m)
+
+            ADD(reg_p, 8)
+            SUB(reg_p_len, 8)
+            CMP(reg_p_len, 8)
+            JGE(loop.begin)
+
+        # no support for jump tables
+        labels = [Label("sw%d" % i) for i in range(0, 8)]
+
+        for i in range(0, 7):
+            CMP(reg_p_len, i)
+            JE(labels[i])
+
+        char = GeneralPurposeRegister64()
+        for i in range(7, 0, -1):
+            LABEL(labels[i])
+            MOVZX(char, byte[reg_p + i - 1])
+            SHL(char, (i - 1) * 8)
+            OR(reg_b, char)
+
+        LABEL(labels[0])
+
+        XOR(reg_v3, reg_b)
+        for _ in range(0, cROUND):
+            sipround(reg_v0, reg_v1, reg_v2, reg_v3)
+        XOR(reg_v0, reg_b)
+
+        XOR(reg_v2, 0xff)
+        for _ in range(0, dROUND):
+            sipround(reg_v0, reg_v1, reg_v2, reg_v3)
+
+        XOR(reg_v0, reg_v1)
+        XOR(reg_v2, reg_v3)
+        XOR(reg_v0, reg_v2)
+
+        RETURN(reg_v0)
+
+
+makeSip("Sum64", (k0, k1, p_base, p_len, p_cap))
+makeSip("Sum64Str", (k0, k1, p_base, p_len))
diff --git a/vendor/github.com/dgryski/go-sip13/sip13_amd64.s b/vendor/github.com/dgryski/go-sip13/sip13_amd64.s
new file mode 100644
index 0000000000..ddd0311ba0
--- /dev/null
+++ b/vendor/github.com/dgryski/go-sip13/sip13_amd64.s
@@ -0,0 +1,304 @@
+//+build !noasm
+
+// Generated by PeachPy 0.2.0 from sip13.py
+
+
+// func Sum64(k0 uint64, k1 uint64, p_base uintptr, p_len int64, p_cap int64) uint64
+TEXT ·Sum64(SB),4,$0-48
+	MOVQ k0+0(FP), AX
+	MOVQ AX, CX
+	MOVQ k1+8(FP), BX
+	MOVQ BX, DX
+	MOVQ $8317987319222330741, DI
+	XORQ DI, AX
+	MOVQ $7237128888997146477, DI
+	XORQ DI, BX
+	MOVQ $7816392313619706465, DI
+	XORQ DI, CX
+	MOVQ $8387220255154660723, DI
+	XORQ DI, DX
+	MOVQ p_base+16(FP), DI
+	MOVQ p_len+24(FP), SI
+	MOVQ SI, BP
+	SHLQ $56, BP
+	CMPQ SI, $8
+	JLT loop_end
+loop_begin:
+		MOVQ 0(DI), R8
+		XORQ R8, DX
+		ADDQ BX, AX
+		ADDQ DX, CX
+		ROLQ $13, BX
+		ROLQ $16, DX
+		XORQ AX, BX
+		XORQ CX, DX
+		ROLQ $32, AX
+		ADDQ BX, CX
+		ADDQ DX, AX
+		ROLQ $17, BX
+		ROLQ $21, DX
+		XORQ CX, BX
+		XORQ AX, DX
+		ROLQ $32, CX
+		XORQ R8, AX
+		ADDQ $8, DI
+		SUBQ $8, SI
+		CMPQ SI, $8
+		JGE loop_begin
+loop_end:
+	CMPQ SI, $0
+	JEQ sw0
+	CMPQ SI, $1
+	JEQ sw1
+	CMPQ SI, $2
+	JEQ sw2
+	CMPQ SI, $3
+	JEQ sw3
+	CMPQ SI, $4
+	JEQ sw4
+	CMPQ SI, $5
+	JEQ sw5
+	CMPQ SI, $6
+	JEQ sw6
+	MOVBQZX 6(DI), SI
+	SHLQ $48, SI
+	ORQ SI, BP
+sw6:
+	MOVBQZX 5(DI), SI
+	SHLQ $40, SI
+	ORQ SI, BP
+sw5:
+	MOVBQZX 4(DI), SI
+	SHLQ $32, SI
+	ORQ SI, BP
+sw4:
+	MOVBQZX 3(DI), SI
+	SHLQ $24, SI
+	ORQ SI, BP
+sw3:
+	MOVBQZX 2(DI), SI
+	SHLQ $16, SI
+	ORQ SI, BP
+sw2:
+	MOVBQZX 1(DI), SI
+	SHLQ $8, SI
+	ORQ SI, BP
+sw1:
+	MOVBQZX 0(DI), SI
+	SHLQ $0, SI
+	ORQ SI, BP
+sw0:
+	XORQ BP, DX
+	ADDQ BX, AX
+	ADDQ DX, CX
+	ROLQ $13, BX
+	ROLQ $16, DX
+	XORQ AX, BX
+	XORQ CX, DX
+	ROLQ $32, AX
+	ADDQ BX, CX
+	ADDQ DX, AX
+	ROLQ $17, BX
+	ROLQ $21, DX
+	XORQ CX, BX
+	XORQ AX, DX
+	ROLQ $32, CX
+	XORQ BP, AX
+	XORQ $255, CX
+	ADDQ BX, AX
+	ADDQ DX, CX
+	ROLQ $13, BX
+	ROLQ $16, DX
+	XORQ AX, BX
+	XORQ CX, DX
+	ROLQ $32, AX
+	ADDQ BX, CX
+	ADDQ DX, AX
+	ROLQ $17, BX
+	ROLQ $21, DX
+	XORQ CX, BX
+	XORQ AX, DX
+	ROLQ $32, CX
+	ADDQ BX, AX
+	ADDQ DX, CX
+	ROLQ $13, BX
+	ROLQ $16, DX
+	XORQ AX, BX
+	XORQ CX, DX
+	ROLQ $32, AX
+	ADDQ BX, CX
+	ADDQ DX, AX
+	ROLQ $17, BX
+	ROLQ $21, DX
+	XORQ CX, BX
+	XORQ AX, DX
+	ROLQ $32, CX
+	ADDQ BX, AX
+	ADDQ DX, CX
+	ROLQ $13, BX
+	ROLQ $16, DX
+	XORQ AX, BX
+	XORQ CX, DX
+	ROLQ $32, AX
+	ADDQ BX, CX
+	ADDQ DX, AX
+	ROLQ $17, BX
+	ROLQ $21, DX
+	XORQ CX, BX
+	XORQ AX, DX
+	ROLQ $32, CX
+	XORQ BX, AX
+	XORQ DX, CX
+	XORQ CX, AX
+	MOVQ AX, ret+40(FP)
+	RET
+
+// func Sum64Str(k0 uint64, k1 uint64, p_base uintptr, p_len int64) uint64
+TEXT ·Sum64Str(SB),4,$0-40
+	MOVQ k0+0(FP), AX
+	MOVQ AX, CX
+	MOVQ k1+8(FP), BX
+	MOVQ BX, DX
+	MOVQ $8317987319222330741, DI
+	XORQ DI, AX
+	MOVQ $7237128888997146477, DI
+	XORQ DI, BX
+	MOVQ $7816392313619706465, DI
+	XORQ DI, CX
+	MOVQ $8387220255154660723, DI
+	XORQ DI, DX
+	MOVQ p_base+16(FP), DI
+	MOVQ p_len+24(FP), SI
+	MOVQ SI, BP
+	SHLQ $56, BP
+	CMPQ SI, $8
+	JLT loop_end
+loop_begin:
+		MOVQ 0(DI), R8
+		XORQ R8, DX
+		ADDQ BX, AX
+		ADDQ DX, CX
+		ROLQ $13, BX
+		ROLQ $16, DX
+		XORQ AX, BX
+		XORQ CX, DX
+		ROLQ $32, AX
+		ADDQ BX, CX
+		ADDQ DX, AX
+		ROLQ $17, BX
+		ROLQ $21, DX
+		XORQ CX, BX
+		XORQ AX, DX
+		ROLQ $32, CX
+		XORQ R8, AX
+		ADDQ $8, DI
+		SUBQ $8, SI
+		CMPQ SI, $8
+		JGE loop_begin
+loop_end:
+	CMPQ SI, $0
+	JEQ sw0
+	CMPQ SI, $1
+	JEQ sw1
+	CMPQ SI, $2
+	JEQ sw2
+	CMPQ SI, $3
+	JEQ sw3
+	CMPQ SI, $4
+	JEQ sw4
+	CMPQ SI, $5
+	JEQ sw5
+	CMPQ SI, $6
+	JEQ sw6
+	MOVBQZX 6(DI), SI
+	SHLQ $48, SI
+	ORQ SI, BP
+sw6:
+	MOVBQZX 5(DI), SI
+	SHLQ $40, SI
+	ORQ SI, BP
+sw5:
+	MOVBQZX 4(DI), SI
+	SHLQ $32, SI
+	ORQ SI, BP
+sw4:
+	MOVBQZX 3(DI), SI
+	SHLQ $24, SI
+	ORQ SI, BP
+sw3:
+	MOVBQZX 2(DI), SI
+	SHLQ $16, SI
+	ORQ SI, BP
+sw2:
+	MOVBQZX 1(DI), SI
+	SHLQ $8, SI
+	ORQ SI, BP
+sw1:
+	MOVBQZX 0(DI), SI
+	SHLQ $0, SI
+	ORQ SI, BP
+sw0:
+	XORQ BP, DX
+	ADDQ BX, AX
+	ADDQ DX, CX
+	ROLQ $13, BX
+	ROLQ $16, DX
+	XORQ AX, BX
+	XORQ CX, DX
+	ROLQ $32, AX
+	ADDQ BX, CX
+	ADDQ DX, AX
+	ROLQ $17, BX
+	ROLQ $21, DX
+	XORQ CX, BX
+	XORQ AX, DX
+	ROLQ $32, CX
+	XORQ BP, AX
+	XORQ $255, CX
+	ADDQ BX, AX
+	ADDQ DX, CX
+	ROLQ $13, BX
+	ROLQ $16, DX
+	XORQ AX, BX
+	XORQ CX, DX
+	ROLQ $32, AX
+	ADDQ BX, CX
+	ADDQ DX, AX
+	ROLQ $17, BX
+	ROLQ $21, DX
+	XORQ CX, BX
+	XORQ AX, DX
+	ROLQ $32, CX
+	ADDQ BX, AX
+	ADDQ DX, CX
+	ROLQ $13, BX
+	ROLQ $16, DX
+	XORQ AX, BX
+	XORQ CX, DX
+	ROLQ $32, AX
+	ADDQ BX, CX
+	ADDQ DX, AX
+	ROLQ $17, BX
+	ROLQ $21, DX
+	XORQ CX, BX
+	XORQ AX, DX
+	ROLQ $32, CX
+	ADDQ BX, AX
+	ADDQ DX, CX
+	ROLQ $13, BX
+	ROLQ $16, DX
+	XORQ AX, BX
+	XORQ CX, DX
+	ROLQ $32, AX
+	ADDQ BX, CX
+	ADDQ DX, AX
+	ROLQ $17, BX
+	ROLQ $21, DX
+	XORQ CX, BX
+	XORQ AX, DX
+	ROLQ $32, CX
+	XORQ BX, AX
+	XORQ DX, CX
+	XORQ CX, AX
+	MOVQ AX, ret+32(FP)
+	RET
diff --git a/vendor/github.com/dgryski/go-sip13/sip13_stub.go b/vendor/github.com/dgryski/go-sip13/sip13_stub.go
new file mode 100644
index 0000000000..e2027eef2e
--- /dev/null
+++ b/vendor/github.com/dgryski/go-sip13/sip13_stub.go
@@ -0,0 +1,11 @@
+// +build amd64,!noasm
+
+package sip13
+
+//go:generate python -m peachpy.x86_64 sip13.py -S -o sip13_amd64.s -mabi=goasm
+//go:noescape
+
+func Sum64(k0, k1 uint64, p []byte) uint64
+
+//go:noescape
+func Sum64Str(k0, k1 uint64, p string) uint64
diff --git a/vendor/github.com/prometheus/tsdb/.gitignore b/vendor/github.com/prometheus/tsdb/.gitignore
deleted file mode 100644
index 5530d1f6fa..0000000000
--- a/vendor/github.com/prometheus/tsdb/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-benchout/
diff --git a/vendor/github.com/prometheus/tsdb/.golangci.yml b/vendor/github.com/prometheus/tsdb/.golangci.yml
deleted file mode 100644
index d9efa75c7c..0000000000
--- a/vendor/github.com/prometheus/tsdb/.golangci.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-# Run only staticcheck for now. Additional linters will be enabled one-by-one.
-linters:
-  enable:
-  - staticcheck
-  disable-all: true
diff --git a/vendor/github.com/prometheus/tsdb/.travis.yml b/vendor/github.com/prometheus/tsdb/.travis.yml
deleted file mode 100644
index 6af68c3dee..0000000000
--- a/vendor/github.com/prometheus/tsdb/.travis.yml
+++ /dev/null
@@ -1,20 +0,0 @@
-dist: trusty
-language: go
-os:
-  - windows
-  - linux
-  - osx
-
-go:
-  - 1.12.x
-
-go_import_path: github.com/prometheus/tsdb
-
-before_install:
-  - if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then choco install make; fi
-
-install:
-  - make deps
-
-script:
-  - if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then make test; else make all; fi
diff --git a/vendor/github.com/prometheus/tsdb/CHANGELOG.md b/vendor/github.com/prometheus/tsdb/CHANGELOG.md
deleted file mode 100644
index 12364b09fc..0000000000
--- a/vendor/github.com/prometheus/tsdb/CHANGELOG.md
+++ /dev/null
@@ -1,108 +0,0 @@
-## master / unreleased
-
-## 0.10.0
-
- - [FEATURE] Added `DBReadOnly` to allow opening a database in read only mode.
-    - `DBReadOnly.Blocks()` exposes a slice of `BlockReader`s.
-    - `BlockReader` interface - removed MinTime/MaxTime methods and now exposes the full block meta via `Meta()`.
- - [FEATURE] `chunckenc.Chunk.Iterator` method now takes a `chunckenc.Iterator` interface as an argument for reuse.
-
-## 0.9.1
-
- - [CHANGE] LiveReader metrics are now injected rather than global.
-
-## 0.9.0
-
- - [FEATURE] Provide option to compress WAL records using Snappy. [#609](https://github.com/prometheus/tsdb/pull/609)
- - [BUGFIX] Re-calculate block size when calling `block.Delete`.
- - [BUGFIX] Re-encode all head chunks at compaction that are open (being appended to) or outside the Maxt block range. This avoids writing out corrupt data. It happens when snapshotting with the head included.
- - [BUGFIX] Improved handling of multiple refs for the same series in WAL reading.
- - [BUGFIX] `prometheus_tsdb_compactions_failed_total` is now incremented on any compaction failure.
- - [CHANGE] The meta file `BlockStats` no longer holds size information. This is now dynamically calculated and kept in memory. It also includes the meta file size which was not included before.
- - [CHANGE] Create new clean segment when starting the WAL.
- - [CHANGE] Renamed metric from `prometheus_tsdb_wal_reader_corruption_errors` to `prometheus_tsdb_wal_reader_corruption_errors_total`.
- - [ENHANCEMENT] Improved atomicity of .tmp block replacement during compaction for usual case.
- - [ENHANCEMENT] Improved postings intersection matching.
- - [ENHANCEMENT] Reduced disk usage for WAL for small setups.
- - [ENHANCEMENT] Optimize queries using regexp for set lookups.
-
-
-## 0.8.0
-
- - [BUGFIX] Calling `Close` more than once on a querier returns an error instead of a panic.
- - [BUGFIX] Don't panic and recover nicely when running out of disk space.
- - [BUGFIX] Correctly handle empty labels.
- - [BUGFIX] Don't crash on an unknown tombstone ref.
- - [ENHANCEMENT] Re-add FromData function to create a chunk from bytes. It is used by Cortex and Thanos.
- - [ENHANCEMENT] Simplify mergedPostings.Seek.
- - [FEATURE]  Added `currentSegment` metric for the current WAL segment it is being written to.
-
-## 0.7.1
-
- - [ENHANCEMENT] Reduce memory usage in mergedPostings.Seek
-
-## 0.7.0
-
- - [CHANGE] tsdb now requires golang 1.12 or higher.
- - [REMOVED] `chunks.NewReader` is removed as it wasn't used anywhere.
- - [REMOVED] `FromData` is considered unused so was removed.
- - [FEATURE] Added option WALSegmentSize -1 to disable the WAL.
- - [BUGFIX] Bugfix in selectOverlappingDirs. Only return the first overlapping blocks.
- - [BUGFIX] Fsync the meta file to persist it on disk to avoid data loss in case of a host crash.
- - [BUGFIX] Fix fd and vm_area leak on error path in chunks.NewDirReader.
- - [BUGFIX] Fix fd and vm_area leak on error path in index.NewFileReader.
- - [BUGFIX] Force persisting the tombstone file to avoid data loss in case of a host crash.
- - [BUGFIX] Keep series that are still in WAL in checkpoints.
- - [ENHANCEMENT] Fast path for EmptyPostings cases in Merge, Intersect and Without.
- - [ENHANCEMENT] Be smarter in how we look at matchers.
- - [ENHANCEMENT] PostListings and NotMatcher now public.
-
-## 0.6.1
-
-  - [BUGFIX] Update `last` after appending a non-overlapping chunk in `chunks.MergeOverlappingChunks`. [#539](https://github.com/prometheus/tsdb/pull/539)
-
-## 0.6.0
-
-  - [CHANGE] `AllowOverlappingBlock` is now `AllowOverlappingBlocks`.
-
-## 0.5.0
-
- - [FEATURE] Time-ovelapping blocks are now allowed. [#370](https://github.com/prometheus/tsdb/pull/370)
-   - Disabled by default and can be enabled via `AllowOverlappingBlock` option.
-   - Added `MergeChunks` function in `chunkenc/xor.go` to merge 2 time-overlapping chunks.
-   - Added `MergeOverlappingChunks` function in `chunks/chunks.go` to merge multiple time-overlapping Chunk Metas.
-   - Added `MinTime` and `MaxTime` method for `BlockReader`.
- - [FEATURE] New `dump` command to tsdb tool to dump all samples.
- - [FEATURE] New `encoding` package for common binary encoding/decoding helpers.
-    - Added to remove some code duplication.
- - [ENHANCEMENT] When closing the db any running compaction will be cancelled so it doesn't block.
-   - `NewLeveledCompactor` takes a context.
- - [CHANGE] `prometheus_tsdb_storage_blocks_bytes_total` is now `prometheus_tsdb_storage_blocks_bytes`.
- - [BUGFIX] Improved Postings Merge performance. Fixes a regression from the the previous release.
- - [BUGFIX] LiveReader can get into an infinite loop on corrupt WALs.
-
-## 0.4.0
-
- - [CHANGE] New `WALSegmentSize` option to override the `DefaultOptions.WALSegmentSize`. Added to allow using smaller wal files. For example using tmpfs on a RPI to minimise the SD card wear out from the constant WAL writes. As part of this change the `DefaultOptions.WALSegmentSize` constant was also exposed.
- - [CHANGE] Empty blocks are not written during compaction [#374](https://github.com/prometheus/tsdb/pull/374)
- - [FEATURE]  Size base retention through `Options.MaxBytes`.  As part of this change:
-   - Added new metrics - `prometheus_tsdb_storage_blocks_bytes_total`, `prometheus_tsdb_size_retentions_total`, `prometheus_tsdb_time_retentions_total`
-   - New public interface `SizeReader: Size() int64`
-   - `OpenBlock` signature changed to take a logger.
- - [REMOVED] `PrefixMatcher` is considered unused so was removed.
- - [CLEANUP] `Options.WALFlushInterval` is removed as it wasn't used anywhere.
- - [FEATURE] Add new `LiveReader` to WAL pacakge. Added to allow live tailing of a WAL segment, used by Prometheus Remote Write after refactor. The main difference between the new reader and the existing `Reader` is that for `LiveReader` a call to `Next()` that returns false does not mean that there will never be more data to read.
-
-## 0.3.1
-
- - [BUGFIX] Fixed most windows test and some actual bugs for unclosed file readers.
-
-## 0.3.0
-
- - [CHANGE] `LastCheckpoint()` used to return just the segment name and now it returns the full relative path.
- - [CHANGE] `NewSegmentsRangeReader()` can now read over miltiple wal ranges by using the new `SegmentRange{}` struct.
- - [CHANGE] `CorruptionErr{}` now also exposes the Segment `Dir` which is added when displaying any errors.
- - [CHANGE] `Head.Init()` is changed to `Head.Init(minValidTime int64)`
- - [CHANGE] `SymbolTable()` renamed to `SymbolTableSize()` to make the name consistent with the  `Block{ symbolTableSize uint64 }` field.
- - [CHANGE] `wal.Reader{}` now exposes `Segment()` for the current segment being read  and `Offset()` for the current offset.
- - [FEATURE] tsdbutil analyze subcomand to find churn, high cardinality, etc.
diff --git a/vendor/github.com/prometheus/tsdb/LICENSE b/vendor/github.com/prometheus/tsdb/LICENSE
deleted file mode 100644
index 261eeb9e9f..0000000000
--- a/vendor/github.com/prometheus/tsdb/LICENSE
+++ /dev/null
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   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.
diff --git a/vendor/github.com/prometheus/tsdb/MAINTAINERS.md b/vendor/github.com/prometheus/tsdb/MAINTAINERS.md
deleted file mode 100644
index dcb57a80df..0000000000
--- a/vendor/github.com/prometheus/tsdb/MAINTAINERS.md
+++ /dev/null
@@ -1,4 +0,0 @@
-Maintainers of this repository:
-
-* Krasi Georgiev <kgeorgie@redhat.com> @krasi-georgiev
-* Goutham Veeramachaneni <gouthamve@gmail.com> @gouthamve
\ No newline at end of file
diff --git a/vendor/github.com/prometheus/tsdb/Makefile b/vendor/github.com/prometheus/tsdb/Makefile
deleted file mode 100644
index 7c35f8df2e..0000000000
--- a/vendor/github.com/prometheus/tsdb/Makefile
+++ /dev/null
@@ -1,33 +0,0 @@
-# Copyright 2018 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.
-
-TSDB_PROJECT_DIR = "."
-TSDB_CLI_DIR="$(TSDB_PROJECT_DIR)/cmd/tsdb"
-TSDB_BIN = "$(TSDB_CLI_DIR)/tsdb"
-TSDB_BENCHMARK_NUM_METRICS ?= 1000
-TSDB_BENCHMARK_DATASET ?= "$(TSDB_PROJECT_DIR)/testdata/20kseries.json"
-TSDB_BENCHMARK_OUTPUT_DIR ?= "$(TSDB_CLI_DIR)/benchout"
-
-include Makefile.common
-
-build:
-	GO111MODULE=$(GO111MODULE) $(GO) build -o $(TSDB_BIN) $(TSDB_CLI_DIR)
-
-bench: build
-	@echo ">> running benchmark, writing result to $(TSDB_BENCHMARK_OUTPUT_DIR)"
-	@$(TSDB_BIN) bench write --metrics=$(TSDB_BENCHMARK_NUM_METRICS) --out=$(TSDB_BENCHMARK_OUTPUT_DIR) $(TSDB_BENCHMARK_DATASET)
-	@$(GO) tool pprof -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/cpu.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/cpuprof.svg
-	@$(GO) tool pprof --inuse_space -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/mem.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/memprof.inuse.svg
-	@$(GO) tool pprof --alloc_space -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/mem.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/memprof.alloc.svg
-	@$(GO) tool pprof -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/block.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/blockprof.svg
-	@$(GO) tool pprof -svg $(TSDB_BIN) $(TSDB_BENCHMARK_OUTPUT_DIR)/mutex.prof > $(TSDB_BENCHMARK_OUTPUT_DIR)/mutexprof.svg
diff --git a/vendor/github.com/prometheus/tsdb/Makefile.common b/vendor/github.com/prometheus/tsdb/Makefile.common
deleted file mode 100644
index db98993d69..0000000000
--- a/vendor/github.com/prometheus/tsdb/Makefile.common
+++ /dev/null
@@ -1,277 +0,0 @@
-# Copyright 2018 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.
-
-
-# A common Makefile that includes rules to be reused in different prometheus projects.
-# !!! Open PRs only against the prometheus/prometheus/Makefile.common repository!
-
-# Example usage :
-# Create the main Makefile in the root project directory.
-# include Makefile.common
-# customTarget:
-# 	@echo ">> Running customTarget"
-#
-
-# Ensure GOBIN is not set during build so that promu is installed to the correct path
-unexport GOBIN
-
-GO           ?= go
-GOFMT        ?= $(GO)fmt
-FIRST_GOPATH := $(firstword $(subst :, ,$(shell $(GO) env GOPATH)))
-GOOPTS       ?=
-GOHOSTOS     ?= $(shell $(GO) env GOHOSTOS)
-GOHOSTARCH   ?= $(shell $(GO) env GOHOSTARCH)
-
-GO_VERSION        ?= $(shell $(GO) version)
-GO_VERSION_NUMBER ?= $(word 3, $(GO_VERSION))
-PRE_GO_111        ?= $(shell echo $(GO_VERSION_NUMBER) | grep -E 'go1\.(10|[0-9])\.')
-
-GOVENDOR :=
-GO111MODULE :=
-ifeq (, $(PRE_GO_111))
-	ifneq (,$(wildcard go.mod))
-		# Enforce Go modules support just in case the directory is inside GOPATH (and for Travis CI).
-		GO111MODULE := on
-
-		ifneq (,$(wildcard vendor))
-			# Always use the local vendor/ directory to satisfy the dependencies.
-			GOOPTS := $(GOOPTS) -mod=vendor
-		endif
-	endif
-else
-	ifneq (,$(wildcard go.mod))
-		ifneq (,$(wildcard vendor))
-$(warning This repository requires Go >= 1.11 because of Go modules)
-$(warning Some recipes may not work as expected as the current Go runtime is '$(GO_VERSION_NUMBER)')
-		endif
-	else
-		# This repository isn't using Go modules (yet).
-		GOVENDOR := $(FIRST_GOPATH)/bin/govendor
-	endif
-endif
-PROMU        := $(FIRST_GOPATH)/bin/promu
-pkgs          = ./...
-
-ifeq (arm, $(GOHOSTARCH))
-	GOHOSTARM ?= $(shell GOARM= $(GO) env GOARM)
-	GO_BUILD_PLATFORM ?= $(GOHOSTOS)-$(GOHOSTARCH)v$(GOHOSTARM)
-else
-	GO_BUILD_PLATFORM ?= $(GOHOSTOS)-$(GOHOSTARCH)
-endif
-
-PROMU_VERSION ?= 0.5.0
-PROMU_URL     := https://github.com/prometheus/promu/releases/download/v$(PROMU_VERSION)/promu-$(PROMU_VERSION).$(GO_BUILD_PLATFORM).tar.gz
-
-GOLANGCI_LINT :=
-GOLANGCI_LINT_OPTS ?=
-GOLANGCI_LINT_VERSION ?= v1.17.1
-# golangci-lint only supports linux, darwin and windows platforms on i386/amd64.
-# windows isn't included here because of the path separator being different.
-ifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux darwin))
-	ifeq ($(GOHOSTARCH),$(filter $(GOHOSTARCH),amd64 i386))
-		GOLANGCI_LINT := $(FIRST_GOPATH)/bin/golangci-lint
-	endif
-endif
-
-PREFIX                  ?= $(shell pwd)
-BIN_DIR                 ?= $(shell pwd)
-DOCKER_IMAGE_TAG        ?= $(subst /,-,$(shell git rev-parse --abbrev-ref HEAD))
-DOCKERFILE_PATH         ?= ./Dockerfile
-DOCKERBUILD_CONTEXT     ?= ./
-DOCKER_REPO             ?= prom
-
-DOCKER_ARCHS            ?= amd64
-
-BUILD_DOCKER_ARCHS = $(addprefix common-docker-,$(DOCKER_ARCHS))
-PUBLISH_DOCKER_ARCHS = $(addprefix common-docker-publish-,$(DOCKER_ARCHS))
-TAG_DOCKER_ARCHS = $(addprefix common-docker-tag-latest-,$(DOCKER_ARCHS))
-
-ifeq ($(GOHOSTARCH),amd64)
-        ifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux freebsd darwin windows))
-                # Only supported on amd64
-                test-flags := -race
-        endif
-endif
-
-# This rule is used to forward a target like "build" to "common-build".  This
-# allows a new "build" target to be defined in a Makefile which includes this
-# one and override "common-build" without override warnings.
-%: common-% ;
-
-.PHONY: common-all
-common-all: precheck style check_license lint unused build test
-
-.PHONY: common-style
-common-style:
-	@echo ">> checking code style"
-	@fmtRes=$$($(GOFMT) -d $$(find . -path ./vendor -prune -o -name '*.go' -print)); \
-	if [ -n "$${fmtRes}" ]; then \
-		echo "gofmt checking failed!"; echo "$${fmtRes}"; echo; \
-		echo "Please ensure you are using $$($(GO) version) for formatting code."; \
-		exit 1; \
-	fi
-
-.PHONY: common-check_license
-common-check_license:
-	@echo ">> checking license header"
-	@licRes=$$(for file in $$(find . -type f -iname '*.go' ! -path './vendor/*') ; do \
-               awk 'NR<=3' $$file | grep -Eq "(Copyright|generated|GENERATED)" || echo $$file; \
-       done); \
-       if [ -n "$${licRes}" ]; then \
-               echo "license header checking failed:"; echo "$${licRes}"; \
-               exit 1; \
-       fi
-
-.PHONY: common-deps
-common-deps:
-	@echo ">> getting dependencies"
-ifdef GO111MODULE
-	GO111MODULE=$(GO111MODULE) $(GO) mod download
-else
-	$(GO) get $(GOOPTS) -t ./...
-endif
-
-.PHONY: common-test-short
-common-test-short:
-	@echo ">> running short tests"
-	GO111MODULE=$(GO111MODULE) $(GO) test -short $(GOOPTS) $(pkgs)
-
-.PHONY: common-test
-common-test:
-	@echo ">> running all tests"
-	GO111MODULE=$(GO111MODULE) $(GO) test $(test-flags) $(GOOPTS) $(pkgs)
-
-.PHONY: common-format
-common-format:
-	@echo ">> formatting code"
-	GO111MODULE=$(GO111MODULE) $(GO) fmt $(pkgs)
-
-.PHONY: common-vet
-common-vet:
-	@echo ">> vetting code"
-	GO111MODULE=$(GO111MODULE) $(GO) vet $(GOOPTS) $(pkgs)
-
-.PHONY: common-lint
-common-lint: $(GOLANGCI_LINT)
-ifdef GOLANGCI_LINT
-	@echo ">> running golangci-lint"
-ifdef GO111MODULE
-# 'go list' needs to be executed before staticcheck to prepopulate the modules cache.
-# Otherwise staticcheck might fail randomly for some reason not yet explained.
-	GO111MODULE=$(GO111MODULE) $(GO) list -e -compiled -test=true -export=false -deps=true -find=false -tags= -- ./... > /dev/null
-	GO111MODULE=$(GO111MODULE) $(GOLANGCI_LINT) run $(GOLANGCI_LINT_OPTS) $(pkgs)
-else
-	$(GOLANGCI_LINT) run $(pkgs)
-endif
-endif
-
-# For backward-compatibility.
-.PHONY: common-staticcheck
-common-staticcheck: lint
-
-.PHONY: common-unused
-common-unused: $(GOVENDOR)
-ifdef GOVENDOR
-	@echo ">> running check for unused packages"
-	@$(GOVENDOR) list +unused | grep . && exit 1 || echo 'No unused packages'
-else
-ifdef GO111MODULE
-	@echo ">> running check for unused/missing packages in go.mod"
-	GO111MODULE=$(GO111MODULE) $(GO) mod tidy
-ifeq (,$(wildcard vendor))
-	@git diff --exit-code -- go.sum go.mod
-else
-	@echo ">> running check for unused packages in vendor/"
-	GO111MODULE=$(GO111MODULE) $(GO) mod vendor
-	@git diff --exit-code -- go.sum go.mod vendor/
-endif
-endif
-endif
-
-.PHONY: common-build
-common-build: promu
-	@echo ">> building binaries"
-	GO111MODULE=$(GO111MODULE) $(PROMU) build --prefix $(PREFIX)
-
-.PHONY: common-tarball
-common-tarball: promu
-	@echo ">> building release tarball"
-	$(PROMU) tarball --prefix $(PREFIX) $(BIN_DIR)
-
-.PHONY: common-docker $(BUILD_DOCKER_ARCHS)
-common-docker: $(BUILD_DOCKER_ARCHS)
-$(BUILD_DOCKER_ARCHS): common-docker-%:
-	docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)" \
-		-f $(DOCKERFILE_PATH) \
-		--build-arg ARCH="$*" \
-		--build-arg OS="linux" \
-		$(DOCKERBUILD_CONTEXT)
-
-.PHONY: common-docker-publish $(PUBLISH_DOCKER_ARCHS)
-common-docker-publish: $(PUBLISH_DOCKER_ARCHS)
-$(PUBLISH_DOCKER_ARCHS): common-docker-publish-%:
-	docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)"
-
-.PHONY: common-docker-tag-latest $(TAG_DOCKER_ARCHS)
-common-docker-tag-latest: $(TAG_DOCKER_ARCHS)
-$(TAG_DOCKER_ARCHS): common-docker-tag-latest-%:
-	docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:latest"
-
-.PHONY: common-docker-manifest
-common-docker-manifest:
-	DOCKER_CLI_EXPERIMENTAL=enabled docker manifest create -a "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" $(foreach ARCH,$(DOCKER_ARCHS),$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$(ARCH):$(DOCKER_IMAGE_TAG))
-	DOCKER_CLI_EXPERIMENTAL=enabled docker manifest push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)"
-
-.PHONY: promu
-promu: $(PROMU)
-
-$(PROMU):
-	$(eval PROMU_TMP := $(shell mktemp -d))
-	curl -s -L $(PROMU_URL) | tar -xvzf - -C $(PROMU_TMP)
-	mkdir -p $(FIRST_GOPATH)/bin
-	cp $(PROMU_TMP)/promu-$(PROMU_VERSION).$(GO_BUILD_PLATFORM)/promu $(FIRST_GOPATH)/bin/promu
-	rm -r $(PROMU_TMP)
-
-.PHONY: proto
-proto:
-	@echo ">> generating code from proto files"
-	@./scripts/genproto.sh
-
-ifdef GOLANGCI_LINT
-$(GOLANGCI_LINT):
-	mkdir -p $(FIRST_GOPATH)/bin
-	curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/$(GOLANGCI_LINT_VERSION)/install.sh \
-		| sed -e '/install -d/d' \
-		| sh -s -- -b $(FIRST_GOPATH)/bin $(GOLANGCI_LINT_VERSION)
-endif
-
-ifdef GOVENDOR
-.PHONY: $(GOVENDOR)
-$(GOVENDOR):
-	GOOS= GOARCH= $(GO) get -u github.com/kardianos/govendor
-endif
-
-.PHONY: precheck
-precheck::
-
-define PRECHECK_COMMAND_template =
-precheck:: $(1)_precheck
-
-PRECHECK_COMMAND_$(1) ?= $(1) $$(strip $$(PRECHECK_OPTIONS_$(1)))
-.PHONY: $(1)_precheck
-$(1)_precheck:
-	@if ! $$(PRECHECK_COMMAND_$(1)) 1>/dev/null 2>&1; then \
-		echo "Execution of '$$(PRECHECK_COMMAND_$(1))' command failed. Is $(1) installed?"; \
-		exit 1; \
-	fi
-endef
diff --git a/vendor/github.com/prometheus/tsdb/README.md b/vendor/github.com/prometheus/tsdb/README.md
deleted file mode 100644
index c62d616d63..0000000000
--- a/vendor/github.com/prometheus/tsdb/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# TSDB 
-
-[![Build Status](https://travis-ci.org/prometheus/tsdb.svg?branch=master)](https://travis-ci.org/prometheus/tsdb)
-[![GoDoc](https://godoc.org/github.com/prometheus/tsdb?status.svg)](https://godoc.org/github.com/prometheus/tsdb)
-[![Go Report Card](https://goreportcard.com/badge/github.com/prometheus/tsdb)](https://goreportcard.com/report/github.com/prometheus/tsdb)
-
-This repository contains the Prometheus storage layer that is used in its 2.x releases.
-
-A writeup of its design can be found [here](https://fabxc.org/blog/2017-04-10-writing-a-tsdb/).
-
-Based on the Gorilla TSDB [white papers](http://www.vldb.org/pvldb/vol8/p1816-teller.pdf).
-
-Video: [Storing 16 Bytes at Scale](https://youtu.be/b_pEevMAC3I) from [PromCon 2017](https://promcon.io/2017-munich/).
-
-See also the [format documentation](docs/format/README.md).
diff --git a/vendor/github.com/prometheus/tsdb/block.go b/vendor/github.com/prometheus/tsdb/block.go
deleted file mode 100644
index d0fe2b2f7f..0000000000
--- a/vendor/github.com/prometheus/tsdb/block.go
+++ /dev/null
@@ -1,656 +0,0 @@
-// Copyright 2017 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.
-
-package tsdb
-
-import (
-	"encoding/json"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"sync"
-
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
-	"github.com/oklog/ulid"
-	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
-)
-
-// IndexWriter serializes the index for a block of series data.
-// The methods must be called in the order they are specified in.
-type IndexWriter interface {
-	// AddSymbols registers all string symbols that are encountered in series
-	// and other indices.
-	AddSymbols(sym map[string]struct{}) error
-
-	// AddSeries populates the index writer with a series and its offsets
-	// of chunks that the index can reference.
-	// Implementations may require series to be insert in increasing order by
-	// their labels.
-	// The reference numbers are used to resolve entries in postings lists that
-	// are added later.
-	AddSeries(ref uint64, l labels.Labels, chunks ...chunks.Meta) error
-
-	// WriteLabelIndex serializes an index from label names to values.
-	// The passed in values chained tuples of strings of the length of names.
-	WriteLabelIndex(names []string, values []string) error
-
-	// WritePostings writes a postings list for a single label pair.
-	// The Postings here contain refs to the series that were added.
-	WritePostings(name, value string, it index.Postings) error
-
-	// Close writes any finalization and closes the resources associated with
-	// the underlying writer.
-	Close() error
-}
-
-// IndexReader provides reading access of serialized index data.
-type IndexReader interface {
-	// Symbols returns a set of string symbols that may occur in series' labels
-	// and indices.
-	Symbols() (map[string]struct{}, error)
-
-	// LabelValues returns the possible label values.
-	LabelValues(names ...string) (index.StringTuples, error)
-
-	// Postings returns the postings list iterator for the label pair.
-	// The Postings here contain the offsets to the series inside the index.
-	// Found IDs are not strictly required to point to a valid Series, e.g. during
-	// background garbage collections.
-	Postings(name, value string) (index.Postings, error)
-
-	// SortedPostings returns a postings list that is reordered to be sorted
-	// by the label set of the underlying series.
-	SortedPostings(index.Postings) index.Postings
-
-	// Series populates the given labels and chunk metas for the series identified
-	// by the reference.
-	// Returns ErrNotFound if the ref does not resolve to a known series.
-	Series(ref uint64, lset *labels.Labels, chks *[]chunks.Meta) error
-
-	// LabelIndices returns a list of string tuples for which a label value index exists.
-	// NOTE: This is deprecated. Use `LabelNames()` instead.
-	LabelIndices() ([][]string, error)
-
-	// LabelNames returns all the unique label names present in the index in sorted order.
-	LabelNames() ([]string, error)
-
-	// Close releases the underlying resources of the reader.
-	Close() error
-}
-
-// StringTuples provides access to a sorted list of string tuples.
-type StringTuples interface {
-	// Total number of tuples in the list.
-	Len() int
-	// At returns the tuple at position i.
-	At(i int) ([]string, error)
-}
-
-// ChunkWriter serializes a time block of chunked series data.
-type ChunkWriter interface {
-	// WriteChunks writes several chunks. The Chunk field of the ChunkMetas
-	// must be populated.
-	// After returning successfully, the Ref fields in the ChunkMetas
-	// are set and can be used to retrieve the chunks from the written data.
-	WriteChunks(chunks ...chunks.Meta) error
-
-	// Close writes any required finalization and closes the resources
-	// associated with the underlying writer.
-	Close() error
-}
-
-// ChunkReader provides reading access of serialized time series data.
-type ChunkReader interface {
-	// Chunk returns the series data chunk with the given reference.
-	Chunk(ref uint64) (chunkenc.Chunk, error)
-
-	// Close releases all underlying resources of the reader.
-	Close() error
-}
-
-// BlockReader provides reading access to a data block.
-type BlockReader interface {
-	// Index returns an IndexReader over the block's data.
-	Index() (IndexReader, error)
-
-	// Chunks returns a ChunkReader over the block's data.
-	Chunks() (ChunkReader, error)
-
-	// Tombstones returns a TombstoneReader over the block's deleted data.
-	Tombstones() (TombstoneReader, error)
-
-	// Meta provides meta information about the block reader.
-	Meta() BlockMeta
-}
-
-// Appendable defines an entity to which data can be appended.
-type Appendable interface {
-	// Appender returns a new Appender against an underlying store.
-	Appender() Appender
-}
-
-// BlockMeta provides meta information about a block.
-type BlockMeta struct {
-	// Unique identifier for the block and its contents. Changes on compaction.
-	ULID ulid.ULID `json:"ulid"`
-
-	// MinTime and MaxTime specify the time range all samples
-	// in the block are in.
-	MinTime int64 `json:"minTime"`
-	MaxTime int64 `json:"maxTime"`
-
-	// Stats about the contents of the block.
-	Stats BlockStats `json:"stats,omitempty"`
-
-	// Information on compactions the block was created from.
-	Compaction BlockMetaCompaction `json:"compaction"`
-
-	// Version of the index format.
-	Version int `json:"version"`
-}
-
-// BlockStats contains stats about contents of a block.
-type BlockStats struct {
-	NumSamples    uint64 `json:"numSamples,omitempty"`
-	NumSeries     uint64 `json:"numSeries,omitempty"`
-	NumChunks     uint64 `json:"numChunks,omitempty"`
-	NumTombstones uint64 `json:"numTombstones,omitempty"`
-}
-
-// BlockDesc describes a block by ULID and time range.
-type BlockDesc struct {
-	ULID    ulid.ULID `json:"ulid"`
-	MinTime int64     `json:"minTime"`
-	MaxTime int64     `json:"maxTime"`
-}
-
-// BlockMetaCompaction holds information about compactions a block went through.
-type BlockMetaCompaction struct {
-	// Maximum number of compaction cycles any source block has
-	// gone through.
-	Level int `json:"level"`
-	// ULIDs of all source head blocks that went into the block.
-	Sources []ulid.ULID `json:"sources,omitempty"`
-	// Indicates that during compaction it resulted in a block without any samples
-	// so it should be deleted on the next reload.
-	Deletable bool `json:"deletable,omitempty"`
-	// Short descriptions of the direct blocks that were used to create
-	// this block.
-	Parents []BlockDesc `json:"parents,omitempty"`
-	Failed  bool        `json:"failed,omitempty"`
-}
-
-const indexFilename = "index"
-const metaFilename = "meta.json"
-
-func chunkDir(dir string) string { return filepath.Join(dir, "chunks") }
-
-func readMetaFile(dir string) (*BlockMeta, int64, error) {
-	b, err := ioutil.ReadFile(filepath.Join(dir, metaFilename))
-	if err != nil {
-		return nil, 0, err
-	}
-	var m BlockMeta
-
-	if err := json.Unmarshal(b, &m); err != nil {
-		return nil, 0, err
-	}
-	if m.Version != 1 {
-		return nil, 0, errors.Errorf("unexpected meta file version %d", m.Version)
-	}
-
-	return &m, int64(len(b)), nil
-}
-
-func writeMetaFile(logger log.Logger, dir string, meta *BlockMeta) (int64, error) {
-	meta.Version = 1
-
-	// Make any changes to the file appear atomic.
-	path := filepath.Join(dir, metaFilename)
-	tmp := path + ".tmp"
-	defer func() {
-		if err := os.RemoveAll(tmp); err != nil {
-			level.Error(logger).Log("msg", "remove tmp file", "err", err.Error())
-		}
-	}()
-
-	f, err := os.Create(tmp)
-	if err != nil {
-		return 0, err
-	}
-
-	jsonMeta, err := json.MarshalIndent(meta, "", "\t")
-	if err != nil {
-		return 0, err
-	}
-
-	var merr tsdb_errors.MultiError
-	n, err := f.Write(jsonMeta)
-	if err != nil {
-		merr.Add(err)
-		merr.Add(f.Close())
-		return 0, merr.Err()
-	}
-
-	// Force the kernel to persist the file on disk to avoid data loss if the host crashes.
-	if err := f.Sync(); err != nil {
-		merr.Add(err)
-		merr.Add(f.Close())
-		return 0, merr.Err()
-	}
-	if err := f.Close(); err != nil {
-		return 0, err
-	}
-	return int64(n), fileutil.Replace(tmp, path)
-}
-
-// Block represents a directory of time series data covering a continuous time range.
-type Block struct {
-	mtx            sync.RWMutex
-	closing        bool
-	pendingReaders sync.WaitGroup
-
-	dir  string
-	meta BlockMeta
-
-	// Symbol Table Size in bytes.
-	// We maintain this variable to avoid recalculation everytime.
-	symbolTableSize uint64
-
-	chunkr     ChunkReader
-	indexr     IndexReader
-	tombstones TombstoneReader
-
-	logger log.Logger
-
-	numBytesChunks    int64
-	numBytesIndex     int64
-	numBytesTombstone int64
-	numBytesMeta      int64
-}
-
-// OpenBlock opens the block in the directory. It can be passed a chunk pool, which is used
-// to instantiate chunk structs.
-func OpenBlock(logger log.Logger, dir string, pool chunkenc.Pool) (pb *Block, err error) {
-	if logger == nil {
-		logger = log.NewNopLogger()
-	}
-	var closers []io.Closer
-	defer func() {
-		if err != nil {
-			var merr tsdb_errors.MultiError
-			merr.Add(err)
-			merr.Add(closeAll(closers))
-			err = merr.Err()
-		}
-	}()
-	meta, sizeMeta, err := readMetaFile(dir)
-	if err != nil {
-		return nil, err
-	}
-
-	cr, err := chunks.NewDirReader(chunkDir(dir), pool)
-	if err != nil {
-		return nil, err
-	}
-	closers = append(closers, cr)
-
-	ir, err := index.NewFileReader(filepath.Join(dir, indexFilename))
-	if err != nil {
-		return nil, err
-	}
-	closers = append(closers, ir)
-
-	tr, sizeTomb, err := readTombstones(dir)
-	if err != nil {
-		return nil, err
-	}
-	closers = append(closers, tr)
-
-	pb = &Block{
-		dir:               dir,
-		meta:              *meta,
-		chunkr:            cr,
-		indexr:            ir,
-		tombstones:        tr,
-		symbolTableSize:   ir.SymbolTableSize(),
-		logger:            logger,
-		numBytesChunks:    cr.Size(),
-		numBytesIndex:     ir.Size(),
-		numBytesTombstone: sizeTomb,
-		numBytesMeta:      sizeMeta,
-	}
-	return pb, nil
-}
-
-// Close closes the on-disk block. It blocks as long as there are readers reading from the block.
-func (pb *Block) Close() error {
-	pb.mtx.Lock()
-	pb.closing = true
-	pb.mtx.Unlock()
-
-	pb.pendingReaders.Wait()
-
-	var merr tsdb_errors.MultiError
-
-	merr.Add(pb.chunkr.Close())
-	merr.Add(pb.indexr.Close())
-	merr.Add(pb.tombstones.Close())
-
-	return merr.Err()
-}
-
-func (pb *Block) String() string {
-	return pb.meta.ULID.String()
-}
-
-// Dir returns the directory of the block.
-func (pb *Block) Dir() string { return pb.dir }
-
-// Meta returns meta information about the block.
-func (pb *Block) Meta() BlockMeta { return pb.meta }
-
-// MinTime returns the min time of the meta.
-func (pb *Block) MinTime() int64 { return pb.meta.MinTime }
-
-// MaxTime returns the max time of the meta.
-func (pb *Block) MaxTime() int64 { return pb.meta.MaxTime }
-
-// Size returns the number of bytes that the block takes up.
-func (pb *Block) Size() int64 {
-	return pb.numBytesChunks + pb.numBytesIndex + pb.numBytesTombstone + pb.numBytesMeta
-}
-
-// ErrClosing is returned when a block is in the process of being closed.
-var ErrClosing = errors.New("block is closing")
-
-func (pb *Block) startRead() error {
-	pb.mtx.RLock()
-	defer pb.mtx.RUnlock()
-
-	if pb.closing {
-		return ErrClosing
-	}
-	pb.pendingReaders.Add(1)
-	return nil
-}
-
-// Index returns a new IndexReader against the block data.
-func (pb *Block) Index() (IndexReader, error) {
-	if err := pb.startRead(); err != nil {
-		return nil, err
-	}
-	return blockIndexReader{ir: pb.indexr, b: pb}, nil
-}
-
-// Chunks returns a new ChunkReader against the block data.
-func (pb *Block) Chunks() (ChunkReader, error) {
-	if err := pb.startRead(); err != nil {
-		return nil, err
-	}
-	return blockChunkReader{ChunkReader: pb.chunkr, b: pb}, nil
-}
-
-// Tombstones returns a new TombstoneReader against the block data.
-func (pb *Block) Tombstones() (TombstoneReader, error) {
-	if err := pb.startRead(); err != nil {
-		return nil, err
-	}
-	return blockTombstoneReader{TombstoneReader: pb.tombstones, b: pb}, nil
-}
-
-// GetSymbolTableSize returns the Symbol Table Size in the index of this block.
-func (pb *Block) GetSymbolTableSize() uint64 {
-	return pb.symbolTableSize
-}
-
-func (pb *Block) setCompactionFailed() error {
-	pb.meta.Compaction.Failed = true
-	n, err := writeMetaFile(pb.logger, pb.dir, &pb.meta)
-	if err != nil {
-		return err
-	}
-	pb.numBytesMeta = n
-	return nil
-}
-
-type blockIndexReader struct {
-	ir IndexReader
-	b  *Block
-}
-
-func (r blockIndexReader) Symbols() (map[string]struct{}, error) {
-	s, err := r.ir.Symbols()
-	return s, errors.Wrapf(err, "block: %s", r.b.Meta().ULID)
-}
-
-func (r blockIndexReader) LabelValues(names ...string) (index.StringTuples, error) {
-	st, err := r.ir.LabelValues(names...)
-	return st, errors.Wrapf(err, "block: %s", r.b.Meta().ULID)
-}
-
-func (r blockIndexReader) Postings(name, value string) (index.Postings, error) {
-	p, err := r.ir.Postings(name, value)
-	if err != nil {
-		return p, errors.Wrapf(err, "block: %s", r.b.Meta().ULID)
-	}
-	return p, nil
-}
-
-func (r blockIndexReader) SortedPostings(p index.Postings) index.Postings {
-	return r.ir.SortedPostings(p)
-}
-
-func (r blockIndexReader) Series(ref uint64, lset *labels.Labels, chks *[]chunks.Meta) error {
-	if err := r.ir.Series(ref, lset, chks); err != nil {
-		return errors.Wrapf(err, "block: %s", r.b.Meta().ULID)
-	}
-	return nil
-}
-
-func (r blockIndexReader) LabelIndices() ([][]string, error) {
-	ss, err := r.ir.LabelIndices()
-	return ss, errors.Wrapf(err, "block: %s", r.b.Meta().ULID)
-}
-
-func (r blockIndexReader) LabelNames() ([]string, error) {
-	return r.b.LabelNames()
-}
-
-func (r blockIndexReader) Close() error {
-	r.b.pendingReaders.Done()
-	return nil
-}
-
-type blockTombstoneReader struct {
-	TombstoneReader
-	b *Block
-}
-
-func (r blockTombstoneReader) Close() error {
-	r.b.pendingReaders.Done()
-	return nil
-}
-
-type blockChunkReader struct {
-	ChunkReader
-	b *Block
-}
-
-func (r blockChunkReader) Close() error {
-	r.b.pendingReaders.Done()
-	return nil
-}
-
-// Delete matching series between mint and maxt in the block.
-func (pb *Block) Delete(mint, maxt int64, ms ...labels.Matcher) error {
-	pb.mtx.Lock()
-	defer pb.mtx.Unlock()
-
-	if pb.closing {
-		return ErrClosing
-	}
-
-	p, err := PostingsForMatchers(pb.indexr, ms...)
-	if err != nil {
-		return errors.Wrap(err, "select series")
-	}
-
-	ir := pb.indexr
-
-	// Choose only valid postings which have chunks in the time-range.
-	stones := newMemTombstones()
-
-	var lset labels.Labels
-	var chks []chunks.Meta
-
-Outer:
-	for p.Next() {
-		err := ir.Series(p.At(), &lset, &chks)
-		if err != nil {
-			return err
-		}
-
-		for _, chk := range chks {
-			if chk.OverlapsClosedInterval(mint, maxt) {
-				// Delete only until the current values and not beyond.
-				tmin, tmax := clampInterval(mint, maxt, chks[0].MinTime, chks[len(chks)-1].MaxTime)
-				stones.addInterval(p.At(), Interval{tmin, tmax})
-				continue Outer
-			}
-		}
-	}
-
-	if p.Err() != nil {
-		return p.Err()
-	}
-
-	err = pb.tombstones.Iter(func(id uint64, ivs Intervals) error {
-		for _, iv := range ivs {
-			stones.addInterval(id, iv)
-		}
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-	pb.tombstones = stones
-	pb.meta.Stats.NumTombstones = pb.tombstones.Total()
-
-	n, err := writeTombstoneFile(pb.logger, pb.dir, pb.tombstones)
-	if err != nil {
-		return err
-	}
-	pb.numBytesTombstone = n
-	n, err = writeMetaFile(pb.logger, pb.dir, &pb.meta)
-	if err != nil {
-		return err
-	}
-	pb.numBytesMeta = n
-	return nil
-}
-
-// CleanTombstones will remove the tombstones and rewrite the block (only if there are any tombstones).
-// If there was a rewrite, then it returns the ULID of the new block written, else nil.
-func (pb *Block) CleanTombstones(dest string, c Compactor) (*ulid.ULID, error) {
-	numStones := 0
-
-	if err := pb.tombstones.Iter(func(id uint64, ivs Intervals) error {
-		numStones += len(ivs)
-		return nil
-	}); err != nil {
-		// This should never happen, as the iteration function only returns nil.
-		panic(err)
-	}
-	if numStones == 0 {
-		return nil, nil
-	}
-
-	meta := pb.Meta()
-	uid, err := c.Write(dest, pb, pb.meta.MinTime, pb.meta.MaxTime, &meta)
-	if err != nil {
-		return nil, err
-	}
-	return &uid, nil
-}
-
-// Snapshot creates snapshot of the block into dir.
-func (pb *Block) Snapshot(dir string) error {
-	blockDir := filepath.Join(dir, pb.meta.ULID.String())
-	if err := os.MkdirAll(blockDir, 0777); err != nil {
-		return errors.Wrap(err, "create snapshot block dir")
-	}
-
-	chunksDir := chunkDir(blockDir)
-	if err := os.MkdirAll(chunksDir, 0777); err != nil {
-		return errors.Wrap(err, "create snapshot chunk dir")
-	}
-
-	// Hardlink meta, index and tombstones
-	for _, fname := range []string{
-		metaFilename,
-		indexFilename,
-		tombstoneFilename,
-	} {
-		if err := os.Link(filepath.Join(pb.dir, fname), filepath.Join(blockDir, fname)); err != nil {
-			return errors.Wrapf(err, "create snapshot %s", fname)
-		}
-	}
-
-	// Hardlink the chunks
-	curChunkDir := chunkDir(pb.dir)
-	files, err := ioutil.ReadDir(curChunkDir)
-	if err != nil {
-		return errors.Wrap(err, "ReadDir the current chunk dir")
-	}
-
-	for _, f := range files {
-		err := os.Link(filepath.Join(curChunkDir, f.Name()), filepath.Join(chunksDir, f.Name()))
-		if err != nil {
-			return errors.Wrap(err, "hardlink a chunk")
-		}
-	}
-
-	return nil
-}
-
-// OverlapsClosedInterval returns true if the block overlaps [mint, maxt].
-func (pb *Block) OverlapsClosedInterval(mint, maxt int64) bool {
-	// The block itself is a half-open interval
-	// [pb.meta.MinTime, pb.meta.MaxTime).
-	return pb.meta.MinTime <= maxt && mint < pb.meta.MaxTime
-}
-
-// LabelNames returns all the unique label names present in the Block in sorted order.
-func (pb *Block) LabelNames() ([]string, error) {
-	return pb.indexr.LabelNames()
-}
-
-func clampInterval(a, b, mint, maxt int64) (int64, int64) {
-	if a < mint {
-		a = mint
-	}
-	if b > maxt {
-		b = maxt
-	}
-	return a, b
-}
diff --git a/vendor/github.com/prometheus/tsdb/checkpoint.go b/vendor/github.com/prometheus/tsdb/checkpoint.go
deleted file mode 100644
index eccfa62be3..0000000000
--- a/vendor/github.com/prometheus/tsdb/checkpoint.go
+++ /dev/null
@@ -1,261 +0,0 @@
-// Copyright 2018 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.
-
-package tsdb
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"math"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"github.com/pkg/errors"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/wal"
-)
-
-// CheckpointStats returns stats about a created checkpoint.
-type CheckpointStats struct {
-	DroppedSeries     int
-	DroppedSamples    int
-	DroppedTombstones int
-	TotalSeries       int // Processed series including dropped ones.
-	TotalSamples      int // Processed samples including dropped ones.
-	TotalTombstones   int // Processed tombstones including dropped ones.
-}
-
-// LastCheckpoint returns the directory name and index of the most recent checkpoint.
-// If dir does not contain any checkpoints, ErrNotFound is returned.
-func LastCheckpoint(dir string) (string, int, error) {
-	files, err := ioutil.ReadDir(dir)
-	if err != nil {
-		return "", 0, err
-	}
-	// Traverse list backwards since there may be multiple checkpoints left.
-	for i := len(files) - 1; i >= 0; i-- {
-		fi := files[i]
-
-		if !strings.HasPrefix(fi.Name(), checkpointPrefix) {
-			continue
-		}
-		if !fi.IsDir() {
-			return "", 0, errors.Errorf("checkpoint %s is not a directory", fi.Name())
-		}
-		idx, err := strconv.Atoi(fi.Name()[len(checkpointPrefix):])
-		if err != nil {
-			continue
-		}
-		return filepath.Join(dir, fi.Name()), idx, nil
-	}
-	return "", 0, ErrNotFound
-}
-
-// DeleteCheckpoints deletes all checkpoints in a directory below a given index.
-func DeleteCheckpoints(dir string, maxIndex int) error {
-	var errs tsdb_errors.MultiError
-
-	files, err := ioutil.ReadDir(dir)
-	if err != nil {
-		return err
-	}
-	for _, fi := range files {
-		if !strings.HasPrefix(fi.Name(), checkpointPrefix) {
-			continue
-		}
-		index, err := strconv.Atoi(fi.Name()[len(checkpointPrefix):])
-		if err != nil || index >= maxIndex {
-			continue
-		}
-		if err := os.RemoveAll(filepath.Join(dir, fi.Name())); err != nil {
-			errs.Add(err)
-		}
-	}
-	return errs.Err()
-}
-
-const checkpointPrefix = "checkpoint."
-
-// Checkpoint creates a compacted checkpoint of segments in range [first, last] in the given WAL.
-// It includes the most recent checkpoint if it exists.
-// All series not satisfying keep and samples below mint are dropped.
-//
-// The checkpoint is stored in a directory named checkpoint.N in the same
-// segmented format as the original WAL itself.
-// This makes it easy to read it through the WAL package and concatenate
-// it with the original WAL.
-func Checkpoint(w *wal.WAL, from, to int, keep func(id uint64) bool, mint int64) (*CheckpointStats, error) {
-	stats := &CheckpointStats{}
-	var sgmReader io.ReadCloser
-
-	{
-
-		var sgmRange []wal.SegmentRange
-		dir, idx, err := LastCheckpoint(w.Dir())
-		if err != nil && err != ErrNotFound {
-			return nil, errors.Wrap(err, "find last checkpoint")
-		}
-		last := idx + 1
-		if err == nil {
-			if from > last {
-				return nil, fmt.Errorf("unexpected gap to last checkpoint. expected:%v, requested:%v", last, from)
-			}
-			// Ignore WAL files below the checkpoint. They shouldn't exist to begin with.
-			from = last
-
-			sgmRange = append(sgmRange, wal.SegmentRange{Dir: dir, Last: math.MaxInt32})
-		}
-
-		sgmRange = append(sgmRange, wal.SegmentRange{Dir: w.Dir(), First: from, Last: to})
-		sgmReader, err = wal.NewSegmentsRangeReader(sgmRange...)
-		if err != nil {
-			return nil, errors.Wrap(err, "create segment reader")
-		}
-		defer sgmReader.Close()
-	}
-
-	cpdir := filepath.Join(w.Dir(), fmt.Sprintf(checkpointPrefix+"%06d", to))
-	cpdirtmp := cpdir + ".tmp"
-
-	if err := os.MkdirAll(cpdirtmp, 0777); err != nil {
-		return nil, errors.Wrap(err, "create checkpoint dir")
-	}
-	cp, err := wal.New(nil, nil, cpdirtmp, w.CompressionEnabled())
-	if err != nil {
-		return nil, errors.Wrap(err, "open checkpoint")
-	}
-
-	// Ensures that an early return caused by an error doesn't leave any tmp files.
-	defer func() {
-		cp.Close()
-		os.RemoveAll(cpdirtmp)
-	}()
-
-	r := wal.NewReader(sgmReader)
-
-	var (
-		series  []RefSeries
-		samples []RefSample
-		tstones []Stone
-		dec     RecordDecoder
-		enc     RecordEncoder
-		buf     []byte
-		recs    [][]byte
-	)
-	for r.Next() {
-		series, samples, tstones = series[:0], samples[:0], tstones[:0]
-
-		// We don't reset the buffer since we batch up multiple records
-		// before writing them to the checkpoint.
-		// Remember where the record for this iteration starts.
-		start := len(buf)
-		rec := r.Record()
-
-		switch dec.Type(rec) {
-		case RecordSeries:
-			series, err = dec.Series(rec, series)
-			if err != nil {
-				return nil, errors.Wrap(err, "decode series")
-			}
-			// Drop irrelevant series in place.
-			repl := series[:0]
-			for _, s := range series {
-				if keep(s.Ref) {
-					repl = append(repl, s)
-				}
-			}
-			if len(repl) > 0 {
-				buf = enc.Series(repl, buf)
-			}
-			stats.TotalSeries += len(series)
-			stats.DroppedSeries += len(series) - len(repl)
-
-		case RecordSamples:
-			samples, err = dec.Samples(rec, samples)
-			if err != nil {
-				return nil, errors.Wrap(err, "decode samples")
-			}
-			// Drop irrelevant samples in place.
-			repl := samples[:0]
-			for _, s := range samples {
-				if s.T >= mint {
-					repl = append(repl, s)
-				}
-			}
-			if len(repl) > 0 {
-				buf = enc.Samples(repl, buf)
-			}
-			stats.TotalSamples += len(samples)
-			stats.DroppedSamples += len(samples) - len(repl)
-
-		case RecordTombstones:
-			tstones, err = dec.Tombstones(rec, tstones)
-			if err != nil {
-				return nil, errors.Wrap(err, "decode deletes")
-			}
-			// Drop irrelevant tombstones in place.
-			repl := tstones[:0]
-			for _, s := range tstones {
-				for _, iv := range s.intervals {
-					if iv.Maxt >= mint {
-						repl = append(repl, s)
-						break
-					}
-				}
-			}
-			if len(repl) > 0 {
-				buf = enc.Tombstones(repl, buf)
-			}
-			stats.TotalTombstones += len(tstones)
-			stats.DroppedTombstones += len(tstones) - len(repl)
-
-		default:
-			return nil, errors.New("invalid record type")
-		}
-		if len(buf[start:]) == 0 {
-			continue // All contents discarded.
-		}
-		recs = append(recs, buf[start:])
-
-		// Flush records in 1 MB increments.
-		if len(buf) > 1*1024*1024 {
-			if err := cp.Log(recs...); err != nil {
-				return nil, errors.Wrap(err, "flush records")
-			}
-			buf, recs = buf[:0], recs[:0]
-		}
-	}
-	// If we hit any corruption during checkpointing, repairing is not an option.
-	// The head won't know which series records are lost.
-	if r.Err() != nil {
-		return nil, errors.Wrap(r.Err(), "read segments")
-	}
-
-	// Flush remaining records.
-	if err := cp.Log(recs...); err != nil {
-		return nil, errors.Wrap(err, "flush records")
-	}
-	if err := cp.Close(); err != nil {
-		return nil, errors.Wrap(err, "close checkpoint")
-	}
-	if err := fileutil.Replace(cpdirtmp, cpdir); err != nil {
-		return nil, errors.Wrap(err, "rename checkpoint directory")
-	}
-
-	return stats, nil
-}
diff --git a/vendor/github.com/prometheus/tsdb/chunkenc/bstream.go b/vendor/github.com/prometheus/tsdb/chunkenc/bstream.go
deleted file mode 100644
index 0a02a73035..0000000000
--- a/vendor/github.com/prometheus/tsdb/chunkenc/bstream.go
+++ /dev/null
@@ -1,200 +0,0 @@
-// Copyright 2017 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.
-
-// The code in this file was largely written by Damian Gryski as part of
-// https://github.com/dgryski/go-tsz and published under the license below.
-// It received minor modifications to suit Prometheus's needs.
-
-// Copyright (c) 2015,2016 Damian Gryski <damian@gryski.com>
-// All rights reserved.
-
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-
-// * Redistributions of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-//
-// * Redistributions in binary form must reproduce the above copyright notice,
-// this list of conditions and the following disclaimer in the documentation
-// and/or other materials provided with the distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package chunkenc
-
-import "io"
-
-// bstream is a stream of bits.
-type bstream struct {
-	stream []byte // the data stream
-	count  uint8  // how many bits are valid in current byte
-}
-
-func newBReader(b []byte) bstream {
-	return bstream{stream: b, count: 8}
-}
-
-func (b *bstream) bytes() []byte {
-	return b.stream
-}
-
-type bit bool
-
-const (
-	zero bit = false
-	one  bit = true
-)
-
-func (b *bstream) writeBit(bit bit) {
-	if b.count == 0 {
-		b.stream = append(b.stream, 0)
-		b.count = 8
-	}
-
-	i := len(b.stream) - 1
-
-	if bit {
-		b.stream[i] |= 1 << (b.count - 1)
-	}
-
-	b.count--
-}
-
-func (b *bstream) writeByte(byt byte) {
-	if b.count == 0 {
-		b.stream = append(b.stream, 0)
-		b.count = 8
-	}
-
-	i := len(b.stream) - 1
-
-	// fill up b.b with b.count bits from byt
-	b.stream[i] |= byt >> (8 - b.count)
-
-	b.stream = append(b.stream, 0)
-	i++
-	b.stream[i] = byt << b.count
-}
-
-func (b *bstream) writeBits(u uint64, nbits int) {
-	u <<= (64 - uint(nbits))
-	for nbits >= 8 {
-		byt := byte(u >> 56)
-		b.writeByte(byt)
-		u <<= 8
-		nbits -= 8
-	}
-
-	for nbits > 0 {
-		b.writeBit((u >> 63) == 1)
-		u <<= 1
-		nbits--
-	}
-}
-
-func (b *bstream) readBit() (bit, error) {
-	if len(b.stream) == 0 {
-		return false, io.EOF
-	}
-
-	if b.count == 0 {
-		b.stream = b.stream[1:]
-
-		if len(b.stream) == 0 {
-			return false, io.EOF
-		}
-		b.count = 8
-	}
-
-	d := (b.stream[0] << (8 - b.count)) & 0x80
-	b.count--
-	return d != 0, nil
-}
-
-func (b *bstream) ReadByte() (byte, error) {
-	return b.readByte()
-}
-
-func (b *bstream) readByte() (byte, error) {
-	if len(b.stream) == 0 {
-		return 0, io.EOF
-	}
-
-	if b.count == 0 {
-		b.stream = b.stream[1:]
-
-		if len(b.stream) == 0 {
-			return 0, io.EOF
-		}
-		return b.stream[0], nil
-	}
-
-	if b.count == 8 {
-		b.count = 0
-		return b.stream[0], nil
-	}
-
-	byt := b.stream[0] << (8 - b.count)
-	b.stream = b.stream[1:]
-
-	if len(b.stream) == 0 {
-		return 0, io.EOF
-	}
-
-	// We just advanced the stream and can assume the shift to be 0.
-	byt |= b.stream[0] >> b.count
-
-	return byt, nil
-}
-
-func (b *bstream) readBits(nbits int) (uint64, error) {
-	var u uint64
-
-	for nbits >= 8 {
-		byt, err := b.readByte()
-		if err != nil {
-			return 0, err
-		}
-
-		u = (u << 8) | uint64(byt)
-		nbits -= 8
-	}
-
-	if nbits == 0 {
-		return u, nil
-	}
-
-	if nbits > int(b.count) {
-		u = (u << uint(b.count)) | uint64((b.stream[0]<<(8-b.count))>>(8-b.count))
-		nbits -= int(b.count)
-		b.stream = b.stream[1:]
-
-		if len(b.stream) == 0 {
-			return 0, io.EOF
-		}
-		b.count = 8
-	}
-
-	u = (u << uint(nbits)) | uint64((b.stream[0]<<(8-b.count))>>(8-uint(nbits)))
-	b.count -= uint8(nbits)
-	return u, nil
-}
diff --git a/vendor/github.com/prometheus/tsdb/chunkenc/chunk.go b/vendor/github.com/prometheus/tsdb/chunkenc/chunk.go
deleted file mode 100644
index 5f9349f05b..0000000000
--- a/vendor/github.com/prometheus/tsdb/chunkenc/chunk.go
+++ /dev/null
@@ -1,138 +0,0 @@
-// Copyright 2017 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.
-
-package chunkenc
-
-import (
-	"fmt"
-	"sync"
-
-	"github.com/pkg/errors"
-)
-
-// Encoding is the identifier for a chunk encoding.
-type Encoding uint8
-
-func (e Encoding) String() string {
-	switch e {
-	case EncNone:
-		return "none"
-	case EncXOR:
-		return "XOR"
-	}
-	return "<unknown>"
-}
-
-// The different available chunk encodings.
-const (
-	EncNone Encoding = iota
-	EncXOR
-)
-
-// Chunk holds a sequence of sample pairs that can be iterated over and appended to.
-type Chunk interface {
-	Bytes() []byte
-	Encoding() Encoding
-	Appender() (Appender, error)
-	// The iterator passed as argument is for re-use.
-	// Depending on implementation, the iterator can
-	// be re-used or a new iterator can be allocated.
-	Iterator(Iterator) Iterator
-	NumSamples() int
-}
-
-// Appender adds sample pairs to a chunk.
-type Appender interface {
-	Append(int64, float64)
-}
-
-// Iterator is a simple iterator that can only get the next value.
-type Iterator interface {
-	At() (int64, float64)
-	Err() error
-	Next() bool
-}
-
-// NewNopIterator returns a new chunk iterator that does not hold any data.
-func NewNopIterator() Iterator {
-	return nopIterator{}
-}
-
-type nopIterator struct{}
-
-func (nopIterator) At() (int64, float64) { return 0, 0 }
-func (nopIterator) Next() bool           { return false }
-func (nopIterator) Err() error           { return nil }
-
-// Pool is used to create and reuse chunk references to avoid allocations.
-type Pool interface {
-	Put(Chunk) error
-	Get(e Encoding, b []byte) (Chunk, error)
-}
-
-// pool is a memory pool of chunk objects.
-type pool struct {
-	xor sync.Pool
-}
-
-// NewPool returns a new pool.
-func NewPool() Pool {
-	return &pool{
-		xor: sync.Pool{
-			New: func() interface{} {
-				return &XORChunk{b: bstream{}}
-			},
-		},
-	}
-}
-
-func (p *pool) Get(e Encoding, b []byte) (Chunk, error) {
-	switch e {
-	case EncXOR:
-		c := p.xor.Get().(*XORChunk)
-		c.b.stream = b
-		c.b.count = 0
-		return c, nil
-	}
-	return nil, errors.Errorf("invalid encoding %q", e)
-}
-
-func (p *pool) Put(c Chunk) error {
-	switch c.Encoding() {
-	case EncXOR:
-		xc, ok := c.(*XORChunk)
-		// This may happen often with wrapped chunks. Nothing we can really do about
-		// it but returning an error would cause a lot of allocations again. Thus,
-		// we just skip it.
-		if !ok {
-			return nil
-		}
-		xc.b.stream = nil
-		xc.b.count = 0
-		p.xor.Put(c)
-	default:
-		return errors.Errorf("invalid encoding %q", c.Encoding())
-	}
-	return nil
-}
-
-// FromData returns a chunk from a byte slice of chunk data.
-// This is there so that users of the library can easily create chunks from
-// bytes.
-func FromData(e Encoding, d []byte) (Chunk, error) {
-	switch e {
-	case EncXOR:
-		return &XORChunk{b: bstream{count: 0, stream: d}}, nil
-	}
-	return nil, fmt.Errorf("unknown chunk encoding: %d", e)
-}
diff --git a/vendor/github.com/prometheus/tsdb/chunkenc/xor.go b/vendor/github.com/prometheus/tsdb/chunkenc/xor.go
deleted file mode 100644
index ca20309f68..0000000000
--- a/vendor/github.com/prometheus/tsdb/chunkenc/xor.go
+++ /dev/null
@@ -1,407 +0,0 @@
-// Copyright 2017 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.
-
-// The code in this file was largely written by Damian Gryski as part of
-// https://github.com/dgryski/go-tsz and published under the license below.
-// It was modified to accommodate reading from byte slices without modifying
-// the underlying bytes, which would panic when reading from mmaped
-// read-only byte slices.
-
-// Copyright (c) 2015,2016 Damian Gryski <damian@gryski.com>
-// All rights reserved.
-
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-
-// * Redistributions of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-//
-// * Redistributions in binary form must reproduce the above copyright notice,
-// this list of conditions and the following disclaimer in the documentation
-// and/or other materials provided with the distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package chunkenc
-
-import (
-	"encoding/binary"
-	"math"
-	"math/bits"
-)
-
-// XORChunk holds XOR encoded sample data.
-type XORChunk struct {
-	b bstream
-}
-
-// NewXORChunk returns a new chunk with XOR encoding of the given size.
-func NewXORChunk() *XORChunk {
-	b := make([]byte, 2, 128)
-	return &XORChunk{b: bstream{stream: b, count: 0}}
-}
-
-// Encoding returns the encoding type.
-func (c *XORChunk) Encoding() Encoding {
-	return EncXOR
-}
-
-// Bytes returns the underlying byte slice of the chunk.
-func (c *XORChunk) Bytes() []byte {
-	return c.b.bytes()
-}
-
-// NumSamples returns the number of samples in the chunk.
-func (c *XORChunk) NumSamples() int {
-	return int(binary.BigEndian.Uint16(c.Bytes()))
-}
-
-// Appender implements the Chunk interface.
-func (c *XORChunk) Appender() (Appender, error) {
-	it := c.iterator(nil)
-
-	// To get an appender we must know the state it would have if we had
-	// appended all existing data from scratch.
-	// We iterate through the end and populate via the iterator's state.
-	for it.Next() {
-	}
-	if err := it.Err(); err != nil {
-		return nil, err
-	}
-
-	a := &xorAppender{
-		b:        &c.b,
-		t:        it.t,
-		v:        it.val,
-		tDelta:   it.tDelta,
-		leading:  it.leading,
-		trailing: it.trailing,
-	}
-	if binary.BigEndian.Uint16(a.b.bytes()) == 0 {
-		a.leading = 0xff
-	}
-	return a, nil
-}
-
-func (c *XORChunk) iterator(it Iterator) *xorIterator {
-	// Should iterators guarantee to act on a copy of the data so it doesn't lock append?
-	// When using striped locks to guard access to chunks, probably yes.
-	// Could only copy data if the chunk is not completed yet.
-	if xorIter, ok := it.(*xorIterator); ok {
-		xorIter.Reset(c.b.bytes())
-		return xorIter
-	}
-	return &xorIterator{
-		// The first 2 bytes contain chunk headers.
-		// We skip that for actual samples.
-		br:       newBReader(c.b.bytes()[2:]),
-		numTotal: binary.BigEndian.Uint16(c.b.bytes()),
-	}
-}
-
-// Iterator implements the Chunk interface.
-func (c *XORChunk) Iterator(it Iterator) Iterator {
-	return c.iterator(it)
-}
-
-type xorAppender struct {
-	b *bstream
-
-	t      int64
-	v      float64
-	tDelta uint64
-
-	leading  uint8
-	trailing uint8
-}
-
-func (a *xorAppender) Append(t int64, v float64) {
-	var tDelta uint64
-	num := binary.BigEndian.Uint16(a.b.bytes())
-
-	if num == 0 {
-		buf := make([]byte, binary.MaxVarintLen64)
-		for _, b := range buf[:binary.PutVarint(buf, t)] {
-			a.b.writeByte(b)
-		}
-		a.b.writeBits(math.Float64bits(v), 64)
-
-	} else if num == 1 {
-		tDelta = uint64(t - a.t)
-
-		buf := make([]byte, binary.MaxVarintLen64)
-		for _, b := range buf[:binary.PutUvarint(buf, tDelta)] {
-			a.b.writeByte(b)
-		}
-
-		a.writeVDelta(v)
-
-	} else {
-		tDelta = uint64(t - a.t)
-		dod := int64(tDelta - a.tDelta)
-
-		// Gorilla has a max resolution of seconds, Prometheus milliseconds.
-		// Thus we use higher value range steps with larger bit size.
-		switch {
-		case dod == 0:
-			a.b.writeBit(zero)
-		case bitRange(dod, 14):
-			a.b.writeBits(0x02, 2) // '10'
-			a.b.writeBits(uint64(dod), 14)
-		case bitRange(dod, 17):
-			a.b.writeBits(0x06, 3) // '110'
-			a.b.writeBits(uint64(dod), 17)
-		case bitRange(dod, 20):
-			a.b.writeBits(0x0e, 4) // '1110'
-			a.b.writeBits(uint64(dod), 20)
-		default:
-			a.b.writeBits(0x0f, 4) // '1111'
-			a.b.writeBits(uint64(dod), 64)
-		}
-
-		a.writeVDelta(v)
-	}
-
-	a.t = t
-	a.v = v
-	binary.BigEndian.PutUint16(a.b.bytes(), num+1)
-	a.tDelta = tDelta
-}
-
-func bitRange(x int64, nbits uint8) bool {
-	return -((1<<(nbits-1))-1) <= x && x <= 1<<(nbits-1)
-}
-
-func (a *xorAppender) writeVDelta(v float64) {
-	vDelta := math.Float64bits(v) ^ math.Float64bits(a.v)
-
-	if vDelta == 0 {
-		a.b.writeBit(zero)
-		return
-	}
-	a.b.writeBit(one)
-
-	leading := uint8(bits.LeadingZeros64(vDelta))
-	trailing := uint8(bits.TrailingZeros64(vDelta))
-
-	// Clamp number of leading zeros to avoid overflow when encoding.
-	if leading >= 32 {
-		leading = 31
-	}
-
-	if a.leading != 0xff && leading >= a.leading && trailing >= a.trailing {
-		a.b.writeBit(zero)
-		a.b.writeBits(vDelta>>a.trailing, 64-int(a.leading)-int(a.trailing))
-	} else {
-		a.leading, a.trailing = leading, trailing
-
-		a.b.writeBit(one)
-		a.b.writeBits(uint64(leading), 5)
-
-		// Note that if leading == trailing == 0, then sigbits == 64.  But that value doesn't actually fit into the 6 bits we have.
-		// Luckily, we never need to encode 0 significant bits, since that would put us in the other case (vdelta == 0).
-		// So instead we write out a 0 and adjust it back to 64 on unpacking.
-		sigbits := 64 - leading - trailing
-		a.b.writeBits(uint64(sigbits), 6)
-		a.b.writeBits(vDelta>>trailing, int(sigbits))
-	}
-}
-
-type xorIterator struct {
-	br       bstream
-	numTotal uint16
-	numRead  uint16
-
-	t   int64
-	val float64
-
-	leading  uint8
-	trailing uint8
-
-	tDelta uint64
-	err    error
-}
-
-func (it *xorIterator) At() (int64, float64) {
-	return it.t, it.val
-}
-
-func (it *xorIterator) Err() error {
-	return it.err
-}
-
-func (it *xorIterator) Reset(b []byte) {
-	// The first 2 bytes contain chunk headers.
-	// We skip that for actual samples.
-	it.br = newBReader(b[2:])
-	it.numTotal = binary.BigEndian.Uint16(b)
-
-	it.numRead = 0
-	it.t = 0
-	it.val = 0
-	it.leading = 0
-	it.trailing = 0
-	it.tDelta = 0
-	it.err = nil
-}
-
-func (it *xorIterator) Next() bool {
-	if it.err != nil || it.numRead == it.numTotal {
-		return false
-	}
-
-	if it.numRead == 0 {
-		t, err := binary.ReadVarint(&it.br)
-		if err != nil {
-			it.err = err
-			return false
-		}
-		v, err := it.br.readBits(64)
-		if err != nil {
-			it.err = err
-			return false
-		}
-		it.t = t
-		it.val = math.Float64frombits(v)
-
-		it.numRead++
-		return true
-	}
-	if it.numRead == 1 {
-		tDelta, err := binary.ReadUvarint(&it.br)
-		if err != nil {
-			it.err = err
-			return false
-		}
-		it.tDelta = tDelta
-		it.t = it.t + int64(it.tDelta)
-
-		return it.readValue()
-	}
-
-	var d byte
-	// read delta-of-delta
-	for i := 0; i < 4; i++ {
-		d <<= 1
-		bit, err := it.br.readBit()
-		if err != nil {
-			it.err = err
-			return false
-		}
-		if bit == zero {
-			break
-		}
-		d |= 1
-	}
-	var sz uint8
-	var dod int64
-	switch d {
-	case 0x00:
-		// dod == 0
-	case 0x02:
-		sz = 14
-	case 0x06:
-		sz = 17
-	case 0x0e:
-		sz = 20
-	case 0x0f:
-		bits, err := it.br.readBits(64)
-		if err != nil {
-			it.err = err
-			return false
-		}
-
-		dod = int64(bits)
-	}
-
-	if sz != 0 {
-		bits, err := it.br.readBits(int(sz))
-		if err != nil {
-			it.err = err
-			return false
-		}
-		if bits > (1 << (sz - 1)) {
-			// or something
-			bits = bits - (1 << sz)
-		}
-		dod = int64(bits)
-	}
-
-	it.tDelta = uint64(int64(it.tDelta) + dod)
-	it.t = it.t + int64(it.tDelta)
-
-	return it.readValue()
-}
-
-func (it *xorIterator) readValue() bool {
-	bit, err := it.br.readBit()
-	if err != nil {
-		it.err = err
-		return false
-	}
-
-	if bit == zero {
-		// it.val = it.val
-	} else {
-		bit, err := it.br.readBit()
-		if err != nil {
-			it.err = err
-			return false
-		}
-		if bit == zero {
-			// reuse leading/trailing zero bits
-			// it.leading, it.trailing = it.leading, it.trailing
-		} else {
-			bits, err := it.br.readBits(5)
-			if err != nil {
-				it.err = err
-				return false
-			}
-			it.leading = uint8(bits)
-
-			bits, err = it.br.readBits(6)
-			if err != nil {
-				it.err = err
-				return false
-			}
-			mbits := uint8(bits)
-			// 0 significant bits here means we overflowed and we actually need 64; see comment in encoder
-			if mbits == 0 {
-				mbits = 64
-			}
-			it.trailing = 64 - it.leading - mbits
-		}
-
-		mbits := int(64 - it.leading - it.trailing)
-		bits, err := it.br.readBits(mbits)
-		if err != nil {
-			it.err = err
-			return false
-		}
-		vbits := math.Float64bits(it.val)
-		vbits ^= (bits << it.trailing)
-		it.val = math.Float64frombits(vbits)
-	}
-
-	it.numRead++
-	return true
-}
diff --git a/vendor/github.com/prometheus/tsdb/chunks/chunks.go b/vendor/github.com/prometheus/tsdb/chunks/chunks.go
deleted file mode 100644
index bd7b9e7658..0000000000
--- a/vendor/github.com/prometheus/tsdb/chunks/chunks.go
+++ /dev/null
@@ -1,512 +0,0 @@
-// Copyright 2017 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.
-
-package chunks
-
-import (
-	"bufio"
-	"encoding/binary"
-	"fmt"
-	"hash"
-	"hash/crc32"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strconv"
-
-	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/chunkenc"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-)
-
-const (
-	// MagicChunks is 4 bytes at the head of a series file.
-	MagicChunks = 0x85BD40DD
-	// MagicChunksSize is the size in bytes of MagicChunks.
-	MagicChunksSize = 4
-
-	chunksFormatV1          = 1
-	ChunksFormatVersionSize = 1
-
-	chunkHeaderSize = MagicChunksSize + ChunksFormatVersionSize
-)
-
-// Meta holds information about a chunk of data.
-type Meta struct {
-	// Ref and Chunk hold either a reference that can be used to retrieve
-	// chunk data or the data itself.
-	// Generally, only one of them is set.
-	Ref   uint64
-	Chunk chunkenc.Chunk
-
-	// Time range the data covers.
-	// When MaxTime == math.MaxInt64 the chunk is still open and being appended to.
-	MinTime, MaxTime int64
-}
-
-// writeHash writes the chunk encoding and raw data into the provided hash.
-func (cm *Meta) writeHash(h hash.Hash, buf []byte) error {
-	buf = append(buf[:0], byte(cm.Chunk.Encoding()))
-	if _, err := h.Write(buf[:1]); err != nil {
-		return err
-	}
-	if _, err := h.Write(cm.Chunk.Bytes()); err != nil {
-		return err
-	}
-	return nil
-}
-
-// OverlapsClosedInterval Returns true if the chunk overlaps [mint, maxt].
-func (cm *Meta) OverlapsClosedInterval(mint, maxt int64) bool {
-	// The chunk itself is a closed interval [cm.MinTime, cm.MaxTime].
-	return cm.MinTime <= maxt && mint <= cm.MaxTime
-}
-
-var (
-	errInvalidSize = fmt.Errorf("invalid size")
-)
-
-var castagnoliTable *crc32.Table
-
-func init() {
-	castagnoliTable = crc32.MakeTable(crc32.Castagnoli)
-}
-
-// newCRC32 initializes a CRC32 hash with a preconfigured polynomial, so the
-// polynomial may be easily changed in one location at a later time, if necessary.
-func newCRC32() hash.Hash32 {
-	return crc32.New(castagnoliTable)
-}
-
-// Writer implements the ChunkWriter interface for the standard
-// serialization format.
-type Writer struct {
-	dirFile *os.File
-	files   []*os.File
-	wbuf    *bufio.Writer
-	n       int64
-	crc32   hash.Hash
-	buf     [binary.MaxVarintLen32]byte
-
-	segmentSize int64
-}
-
-const (
-	defaultChunkSegmentSize = 512 * 1024 * 1024
-)
-
-// NewWriter returns a new writer against the given directory.
-func NewWriter(dir string) (*Writer, error) {
-	if err := os.MkdirAll(dir, 0777); err != nil {
-		return nil, err
-	}
-	dirFile, err := fileutil.OpenDir(dir)
-	if err != nil {
-		return nil, err
-	}
-	cw := &Writer{
-		dirFile:     dirFile,
-		n:           0,
-		crc32:       newCRC32(),
-		segmentSize: defaultChunkSegmentSize,
-	}
-	return cw, nil
-}
-
-func (w *Writer) tail() *os.File {
-	if len(w.files) == 0 {
-		return nil
-	}
-	return w.files[len(w.files)-1]
-}
-
-// finalizeTail writes all pending data to the current tail file,
-// truncates its size, and closes it.
-func (w *Writer) finalizeTail() error {
-	tf := w.tail()
-	if tf == nil {
-		return nil
-	}
-
-	if err := w.wbuf.Flush(); err != nil {
-		return err
-	}
-	if err := tf.Sync(); err != nil {
-		return err
-	}
-	// As the file was pre-allocated, we truncate any superfluous zero bytes.
-	off, err := tf.Seek(0, io.SeekCurrent)
-	if err != nil {
-		return err
-	}
-	if err := tf.Truncate(off); err != nil {
-		return err
-	}
-
-	return tf.Close()
-}
-
-func (w *Writer) cut() error {
-	// Sync current tail to disk and close.
-	if err := w.finalizeTail(); err != nil {
-		return err
-	}
-
-	p, _, err := nextSequenceFile(w.dirFile.Name())
-	if err != nil {
-		return err
-	}
-	f, err := os.OpenFile(p, os.O_WRONLY|os.O_CREATE, 0666)
-	if err != nil {
-		return err
-	}
-	if err = fileutil.Preallocate(f, w.segmentSize, true); err != nil {
-		return err
-	}
-	if err = w.dirFile.Sync(); err != nil {
-		return err
-	}
-
-	// Write header metadata for new file.
-	metab := make([]byte, 8)
-	binary.BigEndian.PutUint32(metab[:MagicChunksSize], MagicChunks)
-	metab[4] = chunksFormatV1
-
-	if _, err := f.Write(metab); err != nil {
-		return err
-	}
-
-	w.files = append(w.files, f)
-	if w.wbuf != nil {
-		w.wbuf.Reset(f)
-	} else {
-		w.wbuf = bufio.NewWriterSize(f, 8*1024*1024)
-	}
-	w.n = 8
-
-	return nil
-}
-
-func (w *Writer) write(b []byte) error {
-	n, err := w.wbuf.Write(b)
-	w.n += int64(n)
-	return err
-}
-
-// MergeOverlappingChunks removes the samples whose timestamp is overlapping.
-// The last appearing sample is retained in case there is overlapping.
-// This assumes that `chks []Meta` is sorted w.r.t. MinTime.
-func MergeOverlappingChunks(chks []Meta) ([]Meta, error) {
-	if len(chks) < 2 {
-		return chks, nil
-	}
-	newChks := make([]Meta, 0, len(chks)) // Will contain the merged chunks.
-	newChks = append(newChks, chks[0])
-	last := 0
-	for _, c := range chks[1:] {
-		// We need to check only the last chunk in newChks.
-		// Reason: (1) newChks[last-1].MaxTime < newChks[last].MinTime (non overlapping)
-		//         (2) As chks are sorted w.r.t. MinTime, newChks[last].MinTime < c.MinTime.
-		// So never overlaps with newChks[last-1] or anything before that.
-		if c.MinTime > newChks[last].MaxTime {
-			newChks = append(newChks, c)
-			last++
-			continue
-		}
-		nc := &newChks[last]
-		if c.MaxTime > nc.MaxTime {
-			nc.MaxTime = c.MaxTime
-		}
-		chk, err := MergeChunks(nc.Chunk, c.Chunk)
-		if err != nil {
-			return nil, err
-		}
-		nc.Chunk = chk
-	}
-
-	return newChks, nil
-}
-
-// MergeChunks vertically merges a and b, i.e., if there is any sample
-// with same timestamp in both a and b, the sample in a is discarded.
-func MergeChunks(a, b chunkenc.Chunk) (*chunkenc.XORChunk, error) {
-	newChunk := chunkenc.NewXORChunk()
-	app, err := newChunk.Appender()
-	if err != nil {
-		return nil, err
-	}
-	ait := a.Iterator(nil)
-	bit := b.Iterator(nil)
-	aok, bok := ait.Next(), bit.Next()
-	for aok && bok {
-		at, av := ait.At()
-		bt, bv := bit.At()
-		if at < bt {
-			app.Append(at, av)
-			aok = ait.Next()
-		} else if bt < at {
-			app.Append(bt, bv)
-			bok = bit.Next()
-		} else {
-			app.Append(bt, bv)
-			aok = ait.Next()
-			bok = bit.Next()
-		}
-	}
-	for aok {
-		at, av := ait.At()
-		app.Append(at, av)
-		aok = ait.Next()
-	}
-	for bok {
-		bt, bv := bit.At()
-		app.Append(bt, bv)
-		bok = bit.Next()
-	}
-	if ait.Err() != nil {
-		return nil, ait.Err()
-	}
-	if bit.Err() != nil {
-		return nil, bit.Err()
-	}
-	return newChunk, nil
-}
-
-func (w *Writer) WriteChunks(chks ...Meta) error {
-	// Calculate maximum space we need and cut a new segment in case
-	// we don't fit into the current one.
-	maxLen := int64(binary.MaxVarintLen32) // The number of chunks.
-	for _, c := range chks {
-		maxLen += binary.MaxVarintLen32 + 1 // The number of bytes in the chunk and its encoding.
-		maxLen += int64(len(c.Chunk.Bytes()))
-		maxLen += 4 // The 4 bytes of crc32
-	}
-	newsz := w.n + maxLen
-
-	if w.wbuf == nil || w.n > w.segmentSize || newsz > w.segmentSize && maxLen <= w.segmentSize {
-		if err := w.cut(); err != nil {
-			return err
-		}
-	}
-
-	var seq = uint64(w.seq()) << 32
-	for i := range chks {
-		chk := &chks[i]
-
-		chk.Ref = seq | uint64(w.n)
-
-		n := binary.PutUvarint(w.buf[:], uint64(len(chk.Chunk.Bytes())))
-
-		if err := w.write(w.buf[:n]); err != nil {
-			return err
-		}
-		w.buf[0] = byte(chk.Chunk.Encoding())
-		if err := w.write(w.buf[:1]); err != nil {
-			return err
-		}
-		if err := w.write(chk.Chunk.Bytes()); err != nil {
-			return err
-		}
-
-		w.crc32.Reset()
-		if err := chk.writeHash(w.crc32, w.buf[:]); err != nil {
-			return err
-		}
-		if err := w.write(w.crc32.Sum(w.buf[:0])); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (w *Writer) seq() int {
-	return len(w.files) - 1
-}
-
-func (w *Writer) Close() error {
-	if err := w.finalizeTail(); err != nil {
-		return err
-	}
-
-	// close dir file (if not windows platform will fail on rename)
-	return w.dirFile.Close()
-}
-
-// ByteSlice abstracts a byte slice.
-type ByteSlice interface {
-	Len() int
-	Range(start, end int) []byte
-}
-
-type realByteSlice []byte
-
-func (b realByteSlice) Len() int {
-	return len(b)
-}
-
-func (b realByteSlice) Range(start, end int) []byte {
-	return b[start:end]
-}
-
-func (b realByteSlice) Sub(start, end int) ByteSlice {
-	return b[start:end]
-}
-
-// Reader implements a ChunkReader for a serialized byte stream
-// of series data.
-type Reader struct {
-	bs   []ByteSlice // The underlying bytes holding the encoded series data.
-	cs   []io.Closer // Closers for resources behind the byte slices.
-	size int64       // The total size of bytes in the reader.
-	pool chunkenc.Pool
-}
-
-func newReader(bs []ByteSlice, cs []io.Closer, pool chunkenc.Pool) (*Reader, error) {
-	cr := Reader{pool: pool, bs: bs, cs: cs}
-	var totalSize int64
-
-	for i, b := range cr.bs {
-		if b.Len() < chunkHeaderSize {
-			return nil, errors.Wrapf(errInvalidSize, "invalid chunk header in segment %d", i)
-		}
-		// Verify magic number.
-		if m := binary.BigEndian.Uint32(b.Range(0, MagicChunksSize)); m != MagicChunks {
-			return nil, errors.Errorf("invalid magic number %x", m)
-		}
-
-		// Verify chunk format version.
-		if v := int(b.Range(MagicChunksSize, MagicChunksSize+ChunksFormatVersionSize)[0]); v != chunksFormatV1 {
-			return nil, errors.Errorf("invalid chunk format version %d", v)
-		}
-		totalSize += int64(b.Len())
-	}
-	cr.size = totalSize
-	return &cr, nil
-}
-
-// NewDirReader returns a new Reader against sequentially numbered files in the
-// given directory.
-func NewDirReader(dir string, pool chunkenc.Pool) (*Reader, error) {
-	files, err := sequenceFiles(dir)
-	if err != nil {
-		return nil, err
-	}
-	if pool == nil {
-		pool = chunkenc.NewPool()
-	}
-
-	var (
-		bs   []ByteSlice
-		cs   []io.Closer
-		merr tsdb_errors.MultiError
-	)
-	for _, fn := range files {
-		f, err := fileutil.OpenMmapFile(fn)
-		if err != nil {
-			merr.Add(errors.Wrap(err, "mmap files"))
-			merr.Add(closeAll(cs))
-			return nil, merr
-		}
-		cs = append(cs, f)
-		bs = append(bs, realByteSlice(f.Bytes()))
-	}
-
-	reader, err := newReader(bs, cs, pool)
-	if err != nil {
-		merr.Add(err)
-		merr.Add(closeAll(cs))
-		return nil, merr
-	}
-	return reader, nil
-}
-
-func (s *Reader) Close() error {
-	return closeAll(s.cs)
-}
-
-// Size returns the size of the chunks.
-func (s *Reader) Size() int64 {
-	return s.size
-}
-
-// Chunk returns a chunk from a given reference.
-func (s *Reader) Chunk(ref uint64) (chunkenc.Chunk, error) {
-	var (
-		sgmSeq    = int(ref >> 32)
-		sgmOffset = int((ref << 32) >> 32)
-	)
-	if sgmSeq >= len(s.bs) {
-		return nil, errors.Errorf("reference sequence %d out of range", sgmSeq)
-	}
-	chkS := s.bs[sgmSeq]
-
-	if sgmOffset >= chkS.Len() {
-		return nil, errors.Errorf("offset %d beyond data size %d", sgmOffset, chkS.Len())
-	}
-	// With the minimum chunk length this should never cause us reading
-	// over the end of the slice.
-	chk := chkS.Range(sgmOffset, sgmOffset+binary.MaxVarintLen32)
-
-	chkLen, n := binary.Uvarint(chk)
-	if n <= 0 {
-		return nil, errors.Errorf("reading chunk length failed with %d", n)
-	}
-	chk = chkS.Range(sgmOffset+n, sgmOffset+n+1+int(chkLen))
-
-	return s.pool.Get(chunkenc.Encoding(chk[0]), chk[1:1+chkLen])
-}
-
-func nextSequenceFile(dir string) (string, int, error) {
-	names, err := fileutil.ReadDir(dir)
-	if err != nil {
-		return "", 0, err
-	}
-
-	i := uint64(0)
-	for _, n := range names {
-		j, err := strconv.ParseUint(n, 10, 64)
-		if err != nil {
-			continue
-		}
-		i = j
-	}
-	return filepath.Join(dir, fmt.Sprintf("%0.6d", i+1)), int(i + 1), nil
-}
-
-func sequenceFiles(dir string) ([]string, error) {
-	files, err := ioutil.ReadDir(dir)
-	if err != nil {
-		return nil, err
-	}
-	var res []string
-
-	for _, fi := range files {
-		if _, err := strconv.ParseUint(fi.Name(), 10, 64); err != nil {
-			continue
-		}
-		res = append(res, filepath.Join(dir, fi.Name()))
-	}
-	return res, nil
-}
-
-func closeAll(cs []io.Closer) error {
-	var merr tsdb_errors.MultiError
-
-	for _, c := range cs {
-		merr.Add(c.Close())
-	}
-	return merr.Err()
-}
diff --git a/vendor/github.com/prometheus/tsdb/compact.go b/vendor/github.com/prometheus/tsdb/compact.go
deleted file mode 100644
index 9443c99e12..0000000000
--- a/vendor/github.com/prometheus/tsdb/compact.go
+++ /dev/null
@@ -1,1034 +0,0 @@
-// Copyright 2017 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.
-
-package tsdb
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"math"
-	"math/rand"
-	"os"
-	"path/filepath"
-	"sort"
-	"time"
-
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
-	"github.com/oklog/ulid"
-	"github.com/pkg/errors"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
-)
-
-// ExponentialBlockRanges returns the time ranges based on the stepSize.
-func ExponentialBlockRanges(minSize int64, steps, stepSize int) []int64 {
-	ranges := make([]int64, 0, steps)
-	curRange := minSize
-	for i := 0; i < steps; i++ {
-		ranges = append(ranges, curRange)
-		curRange = curRange * int64(stepSize)
-	}
-
-	return ranges
-}
-
-// Compactor provides compaction against an underlying storage
-// of time series data.
-type Compactor interface {
-	// Plan returns a set of directories that can be compacted concurrently.
-	// The directories can be overlapping.
-	// Results returned when compactions are in progress are undefined.
-	Plan(dir string) ([]string, error)
-
-	// Write persists a Block into a directory.
-	// No Block is written when resulting Block has 0 samples, and returns empty ulid.ULID{}.
-	Write(dest string, b BlockReader, mint, maxt int64, parent *BlockMeta) (ulid.ULID, error)
-
-	// Compact runs compaction against the provided directories. Must
-	// only be called concurrently with results of Plan().
-	// Can optionally pass a list of already open blocks,
-	// to avoid having to reopen them.
-	// When resulting Block has 0 samples
-	//  * No block is written.
-	//  * The source dirs are marked Deletable.
-	//  * Returns empty ulid.ULID{}.
-	Compact(dest string, dirs []string, open []*Block) (ulid.ULID, error)
-}
-
-// LeveledCompactor implements the Compactor interface.
-type LeveledCompactor struct {
-	metrics   *compactorMetrics
-	logger    log.Logger
-	ranges    []int64
-	chunkPool chunkenc.Pool
-	ctx       context.Context
-}
-
-type compactorMetrics struct {
-	ran               prometheus.Counter
-	populatingBlocks  prometheus.Gauge
-	overlappingBlocks prometheus.Counter
-	duration          prometheus.Histogram
-	chunkSize         prometheus.Histogram
-	chunkSamples      prometheus.Histogram
-	chunkRange        prometheus.Histogram
-}
-
-func newCompactorMetrics(r prometheus.Registerer) *compactorMetrics {
-	m := &compactorMetrics{}
-
-	m.ran = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_compactions_total",
-		Help: "Total number of compactions that were executed for the partition.",
-	})
-	m.populatingBlocks = prometheus.NewGauge(prometheus.GaugeOpts{
-		Name: "prometheus_tsdb_compaction_populating_block",
-		Help: "Set to 1 when a block is currently being written to the disk.",
-	})
-	m.overlappingBlocks = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_vertical_compactions_total",
-		Help: "Total number of compactions done on overlapping blocks.",
-	})
-	m.duration = prometheus.NewHistogram(prometheus.HistogramOpts{
-		Name:    "prometheus_tsdb_compaction_duration_seconds",
-		Help:    "Duration of compaction runs",
-		Buckets: prometheus.ExponentialBuckets(1, 2, 10),
-	})
-	m.chunkSize = prometheus.NewHistogram(prometheus.HistogramOpts{
-		Name:    "prometheus_tsdb_compaction_chunk_size_bytes",
-		Help:    "Final size of chunks on their first compaction",
-		Buckets: prometheus.ExponentialBuckets(32, 1.5, 12),
-	})
-	m.chunkSamples = prometheus.NewHistogram(prometheus.HistogramOpts{
-		Name:    "prometheus_tsdb_compaction_chunk_samples",
-		Help:    "Final number of samples on their first compaction",
-		Buckets: prometheus.ExponentialBuckets(4, 1.5, 12),
-	})
-	m.chunkRange = prometheus.NewHistogram(prometheus.HistogramOpts{
-		Name:    "prometheus_tsdb_compaction_chunk_range_seconds",
-		Help:    "Final time range of chunks on their first compaction",
-		Buckets: prometheus.ExponentialBuckets(100, 4, 10),
-	})
-
-	if r != nil {
-		r.MustRegister(
-			m.ran,
-			m.populatingBlocks,
-			m.overlappingBlocks,
-			m.duration,
-			m.chunkRange,
-			m.chunkSamples,
-			m.chunkSize,
-		)
-	}
-	return m
-}
-
-// NewLeveledCompactor returns a LeveledCompactor.
-func NewLeveledCompactor(ctx context.Context, r prometheus.Registerer, l log.Logger, ranges []int64, pool chunkenc.Pool) (*LeveledCompactor, error) {
-	if len(ranges) == 0 {
-		return nil, errors.Errorf("at least one range must be provided")
-	}
-	if pool == nil {
-		pool = chunkenc.NewPool()
-	}
-	if l == nil {
-		l = log.NewNopLogger()
-	}
-	return &LeveledCompactor{
-		ranges:    ranges,
-		chunkPool: pool,
-		logger:    l,
-		metrics:   newCompactorMetrics(r),
-		ctx:       ctx,
-	}, nil
-}
-
-type dirMeta struct {
-	dir  string
-	meta *BlockMeta
-}
-
-// Plan returns a list of compactable blocks in the provided directory.
-func (c *LeveledCompactor) Plan(dir string) ([]string, error) {
-	dirs, err := blockDirs(dir)
-	if err != nil {
-		return nil, err
-	}
-	if len(dirs) < 1 {
-		return nil, nil
-	}
-
-	var dms []dirMeta
-	for _, dir := range dirs {
-		meta, _, err := readMetaFile(dir)
-		if err != nil {
-			return nil, err
-		}
-		dms = append(dms, dirMeta{dir, meta})
-	}
-	return c.plan(dms)
-}
-
-func (c *LeveledCompactor) plan(dms []dirMeta) ([]string, error) {
-	sort.Slice(dms, func(i, j int) bool {
-		return dms[i].meta.MinTime < dms[j].meta.MinTime
-	})
-
-	res := c.selectOverlappingDirs(dms)
-	if len(res) > 0 {
-		return res, nil
-	}
-	// No overlapping blocks, do compaction the usual way.
-	// We do not include a recently created block with max(minTime), so the block which was just created from WAL.
-	// This gives users a window of a full block size to piece-wise backup new data without having to care about data overlap.
-	dms = dms[:len(dms)-1]
-
-	for _, dm := range c.selectDirs(dms) {
-		res = append(res, dm.dir)
-	}
-	if len(res) > 0 {
-		return res, nil
-	}
-
-	// Compact any blocks with big enough time range that have >5% tombstones.
-	for i := len(dms) - 1; i >= 0; i-- {
-		meta := dms[i].meta
-		if meta.MaxTime-meta.MinTime < c.ranges[len(c.ranges)/2] {
-			break
-		}
-		if float64(meta.Stats.NumTombstones)/float64(meta.Stats.NumSeries+1) > 0.05 {
-			return []string{dms[i].dir}, nil
-		}
-	}
-
-	return nil, nil
-}
-
-// selectDirs returns the dir metas that should be compacted into a single new block.
-// If only a single block range is configured, the result is always nil.
-func (c *LeveledCompactor) selectDirs(ds []dirMeta) []dirMeta {
-	if len(c.ranges) < 2 || len(ds) < 1 {
-		return nil
-	}
-
-	highTime := ds[len(ds)-1].meta.MinTime
-
-	for _, iv := range c.ranges[1:] {
-		parts := splitByRange(ds, iv)
-		if len(parts) == 0 {
-			continue
-		}
-
-	Outer:
-		for _, p := range parts {
-			// Do not select the range if it has a block whose compaction failed.
-			for _, dm := range p {
-				if dm.meta.Compaction.Failed {
-					continue Outer
-				}
-			}
-
-			mint := p[0].meta.MinTime
-			maxt := p[len(p)-1].meta.MaxTime
-			// Pick the range of blocks if it spans the full range (potentially with gaps)
-			// or is before the most recent block.
-			// This ensures we don't compact blocks prematurely when another one of the same
-			// size still fits in the range.
-			if (maxt-mint == iv || maxt <= highTime) && len(p) > 1 {
-				return p
-			}
-		}
-	}
-
-	return nil
-}
-
-// selectOverlappingDirs returns all dirs with overlapping time ranges.
-// It expects sorted input by mint and returns the overlapping dirs in the same order as received.
-func (c *LeveledCompactor) selectOverlappingDirs(ds []dirMeta) []string {
-	if len(ds) < 2 {
-		return nil
-	}
-	var overlappingDirs []string
-	globalMaxt := ds[0].meta.MaxTime
-	for i, d := range ds[1:] {
-		if d.meta.MinTime < globalMaxt {
-			if len(overlappingDirs) == 0 { // When it is the first overlap, need to add the last one as well.
-				overlappingDirs = append(overlappingDirs, ds[i].dir)
-			}
-			overlappingDirs = append(overlappingDirs, d.dir)
-		} else if len(overlappingDirs) > 0 {
-			break
-		}
-		if d.meta.MaxTime > globalMaxt {
-			globalMaxt = d.meta.MaxTime
-		}
-	}
-	return overlappingDirs
-}
-
-// splitByRange splits the directories by the time range. The range sequence starts at 0.
-//
-// For example, if we have blocks [0-10, 10-20, 50-60, 90-100] and the split range tr is 30
-// it returns [0-10, 10-20], [50-60], [90-100].
-func splitByRange(ds []dirMeta, tr int64) [][]dirMeta {
-	var splitDirs [][]dirMeta
-
-	for i := 0; i < len(ds); {
-		var (
-			group []dirMeta
-			t0    int64
-			m     = ds[i].meta
-		)
-		// Compute start of aligned time range of size tr closest to the current block's start.
-		if m.MinTime >= 0 {
-			t0 = tr * (m.MinTime / tr)
-		} else {
-			t0 = tr * ((m.MinTime - tr + 1) / tr)
-		}
-		// Skip blocks that don't fall into the range. This can happen via mis-alignment or
-		// by being the multiple of the intended range.
-		if m.MaxTime > t0+tr {
-			i++
-			continue
-		}
-
-		// Add all dirs to the current group that are within [t0, t0+tr].
-		for ; i < len(ds); i++ {
-			// Either the block falls into the next range or doesn't fit at all (checked above).
-			if ds[i].meta.MaxTime > t0+tr {
-				break
-			}
-			group = append(group, ds[i])
-		}
-
-		if len(group) > 0 {
-			splitDirs = append(splitDirs, group)
-		}
-	}
-
-	return splitDirs
-}
-
-func compactBlockMetas(uid ulid.ULID, blocks ...*BlockMeta) *BlockMeta {
-	res := &BlockMeta{
-		ULID:    uid,
-		MinTime: blocks[0].MinTime,
-	}
-
-	sources := map[ulid.ULID]struct{}{}
-	// For overlapping blocks, the Maxt can be
-	// in any block so we track it globally.
-	maxt := int64(math.MinInt64)
-
-	for _, b := range blocks {
-		if b.MaxTime > maxt {
-			maxt = b.MaxTime
-		}
-		if b.Compaction.Level > res.Compaction.Level {
-			res.Compaction.Level = b.Compaction.Level
-		}
-		for _, s := range b.Compaction.Sources {
-			sources[s] = struct{}{}
-		}
-		res.Compaction.Parents = append(res.Compaction.Parents, BlockDesc{
-			ULID:    b.ULID,
-			MinTime: b.MinTime,
-			MaxTime: b.MaxTime,
-		})
-	}
-	res.Compaction.Level++
-
-	for s := range sources {
-		res.Compaction.Sources = append(res.Compaction.Sources, s)
-	}
-	sort.Slice(res.Compaction.Sources, func(i, j int) bool {
-		return res.Compaction.Sources[i].Compare(res.Compaction.Sources[j]) < 0
-	})
-
-	res.MaxTime = maxt
-	return res
-}
-
-// Compact creates a new block in the compactor's directory from the blocks in the
-// provided directories.
-func (c *LeveledCompactor) Compact(dest string, dirs []string, open []*Block) (uid ulid.ULID, err error) {
-	var (
-		blocks []BlockReader
-		bs     []*Block
-		metas  []*BlockMeta
-		uids   []string
-	)
-	start := time.Now()
-
-	for _, d := range dirs {
-		meta, _, err := readMetaFile(d)
-		if err != nil {
-			return uid, err
-		}
-
-		var b *Block
-
-		// Use already open blocks if we can, to avoid
-		// having the index data in memory twice.
-		for _, o := range open {
-			if meta.ULID == o.Meta().ULID {
-				b = o
-				break
-			}
-		}
-
-		if b == nil {
-			var err error
-			b, err = OpenBlock(c.logger, d, c.chunkPool)
-			if err != nil {
-				return uid, err
-			}
-			defer b.Close()
-		}
-
-		metas = append(metas, meta)
-		blocks = append(blocks, b)
-		bs = append(bs, b)
-		uids = append(uids, meta.ULID.String())
-	}
-
-	entropy := rand.New(rand.NewSource(time.Now().UnixNano()))
-	uid = ulid.MustNew(ulid.Now(), entropy)
-
-	meta := compactBlockMetas(uid, metas...)
-	err = c.write(dest, meta, blocks...)
-	if err == nil {
-		if meta.Stats.NumSamples == 0 {
-			for _, b := range bs {
-				b.meta.Compaction.Deletable = true
-				n, err := writeMetaFile(c.logger, b.dir, &b.meta)
-				if err != nil {
-					level.Error(c.logger).Log(
-						"msg", "Failed to write 'Deletable' to meta file after compaction",
-						"ulid", b.meta.ULID,
-					)
-				}
-				b.numBytesMeta = n
-			}
-			uid = ulid.ULID{}
-			level.Info(c.logger).Log(
-				"msg", "compact blocks resulted in empty block",
-				"count", len(blocks),
-				"sources", fmt.Sprintf("%v", uids),
-				"duration", time.Since(start),
-			)
-		} else {
-			level.Info(c.logger).Log(
-				"msg", "compact blocks",
-				"count", len(blocks),
-				"mint", meta.MinTime,
-				"maxt", meta.MaxTime,
-				"ulid", meta.ULID,
-				"sources", fmt.Sprintf("%v", uids),
-				"duration", time.Since(start),
-			)
-		}
-		return uid, nil
-	}
-
-	var merr tsdb_errors.MultiError
-	merr.Add(err)
-	if err != context.Canceled {
-		for _, b := range bs {
-			if err := b.setCompactionFailed(); err != nil {
-				merr.Add(errors.Wrapf(err, "setting compaction failed for block: %s", b.Dir()))
-			}
-		}
-	}
-
-	return uid, merr
-}
-
-func (c *LeveledCompactor) Write(dest string, b BlockReader, mint, maxt int64, parent *BlockMeta) (ulid.ULID, error) {
-	start := time.Now()
-
-	entropy := rand.New(rand.NewSource(time.Now().UnixNano()))
-	uid := ulid.MustNew(ulid.Now(), entropy)
-
-	meta := &BlockMeta{
-		ULID:    uid,
-		MinTime: mint,
-		MaxTime: maxt,
-	}
-	meta.Compaction.Level = 1
-	meta.Compaction.Sources = []ulid.ULID{uid}
-
-	if parent != nil {
-		meta.Compaction.Parents = []BlockDesc{
-			{ULID: parent.ULID, MinTime: parent.MinTime, MaxTime: parent.MaxTime},
-		}
-	}
-
-	err := c.write(dest, meta, b)
-	if err != nil {
-		return uid, err
-	}
-
-	if meta.Stats.NumSamples == 0 {
-		return ulid.ULID{}, nil
-	}
-
-	level.Info(c.logger).Log(
-		"msg", "write block",
-		"mint", meta.MinTime,
-		"maxt", meta.MaxTime,
-		"ulid", meta.ULID,
-		"duration", time.Since(start),
-	)
-	return uid, nil
-}
-
-// instrumentedChunkWriter is used for level 1 compactions to record statistics
-// about compacted chunks.
-type instrumentedChunkWriter struct {
-	ChunkWriter
-
-	size    prometheus.Histogram
-	samples prometheus.Histogram
-	trange  prometheus.Histogram
-}
-
-func (w *instrumentedChunkWriter) WriteChunks(chunks ...chunks.Meta) error {
-	for _, c := range chunks {
-		w.size.Observe(float64(len(c.Chunk.Bytes())))
-		w.samples.Observe(float64(c.Chunk.NumSamples()))
-		w.trange.Observe(float64(c.MaxTime - c.MinTime))
-	}
-	return w.ChunkWriter.WriteChunks(chunks...)
-}
-
-// write creates a new block that is the union of the provided blocks into dir.
-// It cleans up all files of the old blocks after completing successfully.
-func (c *LeveledCompactor) write(dest string, meta *BlockMeta, blocks ...BlockReader) (err error) {
-	dir := filepath.Join(dest, meta.ULID.String())
-	tmp := dir + ".tmp"
-	var closers []io.Closer
-	defer func(t time.Time) {
-		var merr tsdb_errors.MultiError
-		merr.Add(err)
-		merr.Add(closeAll(closers))
-		err = merr.Err()
-
-		// RemoveAll returns no error when tmp doesn't exist so it is safe to always run it.
-		if err := os.RemoveAll(tmp); err != nil {
-			level.Error(c.logger).Log("msg", "removed tmp folder after failed compaction", "err", err.Error())
-		}
-		c.metrics.ran.Inc()
-		c.metrics.duration.Observe(time.Since(t).Seconds())
-	}(time.Now())
-
-	if err = os.RemoveAll(tmp); err != nil {
-		return err
-	}
-
-	if err = os.MkdirAll(tmp, 0777); err != nil {
-		return err
-	}
-
-	// Populate chunk and index files into temporary directory with
-	// data of all blocks.
-	var chunkw ChunkWriter
-
-	chunkw, err = chunks.NewWriter(chunkDir(tmp))
-	if err != nil {
-		return errors.Wrap(err, "open chunk writer")
-	}
-	closers = append(closers, chunkw)
-	// Record written chunk sizes on level 1 compactions.
-	if meta.Compaction.Level == 1 {
-		chunkw = &instrumentedChunkWriter{
-			ChunkWriter: chunkw,
-			size:        c.metrics.chunkSize,
-			samples:     c.metrics.chunkSamples,
-			trange:      c.metrics.chunkRange,
-		}
-	}
-
-	indexw, err := index.NewWriter(filepath.Join(tmp, indexFilename))
-	if err != nil {
-		return errors.Wrap(err, "open index writer")
-	}
-	closers = append(closers, indexw)
-
-	if err := c.populateBlock(blocks, meta, indexw, chunkw); err != nil {
-		return errors.Wrap(err, "write compaction")
-	}
-
-	select {
-	case <-c.ctx.Done():
-		return c.ctx.Err()
-	default:
-	}
-
-	// We are explicitly closing them here to check for error even
-	// though these are covered under defer. This is because in Windows,
-	// you cannot delete these unless they are closed and the defer is to
-	// make sure they are closed if the function exits due to an error above.
-	var merr tsdb_errors.MultiError
-	for _, w := range closers {
-		merr.Add(w.Close())
-	}
-	closers = closers[:0] // Avoid closing the writers twice in the defer.
-	if merr.Err() != nil {
-		return merr.Err()
-	}
-
-	// Populated block is empty, so exit early.
-	if meta.Stats.NumSamples == 0 {
-		return nil
-	}
-
-	if _, err = writeMetaFile(c.logger, tmp, meta); err != nil {
-		return errors.Wrap(err, "write merged meta")
-	}
-
-	// Create an empty tombstones file.
-	if _, err := writeTombstoneFile(c.logger, tmp, newMemTombstones()); err != nil {
-		return errors.Wrap(err, "write new tombstones file")
-	}
-
-	df, err := fileutil.OpenDir(tmp)
-	if err != nil {
-		return errors.Wrap(err, "open temporary block dir")
-	}
-	defer func() {
-		if df != nil {
-			df.Close()
-		}
-	}()
-
-	if err := df.Sync(); err != nil {
-		return errors.Wrap(err, "sync temporary dir file")
-	}
-
-	// Close temp dir before rename block dir (for windows platform).
-	if err = df.Close(); err != nil {
-		return errors.Wrap(err, "close temporary dir")
-	}
-	df = nil
-
-	// Block successfully written, make visible and remove old ones.
-	if err := fileutil.Replace(tmp, dir); err != nil {
-		return errors.Wrap(err, "rename block dir")
-	}
-
-	return nil
-}
-
-// populateBlock fills the index and chunk writers with new data gathered as the union
-// of the provided blocks. It returns meta information for the new block.
-// It expects sorted blocks input by mint.
-func (c *LeveledCompactor) populateBlock(blocks []BlockReader, meta *BlockMeta, indexw IndexWriter, chunkw ChunkWriter) (err error) {
-	if len(blocks) == 0 {
-		return errors.New("cannot populate block from no readers")
-	}
-
-	var (
-		set         ChunkSeriesSet
-		allSymbols  = make(map[string]struct{}, 1<<16)
-		closers     = []io.Closer{}
-		overlapping bool
-	)
-	defer func() {
-		var merr tsdb_errors.MultiError
-		merr.Add(err)
-		merr.Add(closeAll(closers))
-		err = merr.Err()
-		c.metrics.populatingBlocks.Set(0)
-	}()
-	c.metrics.populatingBlocks.Set(1)
-
-	globalMaxt := blocks[0].Meta().MaxTime
-	for i, b := range blocks {
-		select {
-		case <-c.ctx.Done():
-			return c.ctx.Err()
-		default:
-		}
-
-		if !overlapping {
-			if i > 0 && b.Meta().MinTime < globalMaxt {
-				c.metrics.overlappingBlocks.Inc()
-				overlapping = true
-				level.Warn(c.logger).Log("msg", "found overlapping blocks during compaction", "ulid", meta.ULID)
-			}
-			if b.Meta().MaxTime > globalMaxt {
-				globalMaxt = b.Meta().MaxTime
-			}
-		}
-
-		indexr, err := b.Index()
-		if err != nil {
-			return errors.Wrapf(err, "open index reader for block %s", b)
-		}
-		closers = append(closers, indexr)
-
-		chunkr, err := b.Chunks()
-		if err != nil {
-			return errors.Wrapf(err, "open chunk reader for block %s", b)
-		}
-		closers = append(closers, chunkr)
-
-		tombsr, err := b.Tombstones()
-		if err != nil {
-			return errors.Wrapf(err, "open tombstone reader for block %s", b)
-		}
-		closers = append(closers, tombsr)
-
-		symbols, err := indexr.Symbols()
-		if err != nil {
-			return errors.Wrap(err, "read symbols")
-		}
-		for s := range symbols {
-			allSymbols[s] = struct{}{}
-		}
-
-		all, err := indexr.Postings(index.AllPostingsKey())
-		if err != nil {
-			return err
-		}
-		all = indexr.SortedPostings(all)
-
-		s := newCompactionSeriesSet(indexr, chunkr, tombsr, all)
-
-		if i == 0 {
-			set = s
-			continue
-		}
-		set, err = newCompactionMerger(set, s)
-		if err != nil {
-			return err
-		}
-	}
-
-	// We fully rebuild the postings list index from merged series.
-	var (
-		postings = index.NewMemPostings()
-		values   = map[string]stringset{}
-		i        = uint64(0)
-	)
-
-	if err := indexw.AddSymbols(allSymbols); err != nil {
-		return errors.Wrap(err, "add symbols")
-	}
-
-	delIter := &deletedIterator{}
-	for set.Next() {
-		select {
-		case <-c.ctx.Done():
-			return c.ctx.Err()
-		default:
-		}
-
-		lset, chks, dranges := set.At() // The chunks here are not fully deleted.
-		if overlapping {
-			// If blocks are overlapping, it is possible to have unsorted chunks.
-			sort.Slice(chks, func(i, j int) bool {
-				return chks[i].MinTime < chks[j].MinTime
-			})
-		}
-
-		// Skip the series with all deleted chunks.
-		if len(chks) == 0 {
-			continue
-		}
-
-		for i, chk := range chks {
-			// Re-encode head chunks that are still open (being appended to) or
-			// outside the compacted MaxTime range.
-			// The chunk.Bytes() method is not safe for open chunks hence the re-encoding.
-			// This happens when snapshotting the head block.
-			//
-			// Block time range is half-open: [meta.MinTime, meta.MaxTime) and
-			// chunks are closed hence the chk.MaxTime >= meta.MaxTime check.
-			//
-			// TODO think how to avoid the typecasting to verify when it is head block.
-			if _, isHeadChunk := chk.Chunk.(*safeChunk); isHeadChunk && chk.MaxTime >= meta.MaxTime {
-				dranges = append(dranges, Interval{Mint: meta.MaxTime, Maxt: math.MaxInt64})
-
-			} else
-			// Sanity check for disk blocks.
-			// chk.MaxTime == meta.MaxTime shouldn't happen as well, but will brake many users so not checking for that.
-			if chk.MinTime < meta.MinTime || chk.MaxTime > meta.MaxTime {
-				return errors.Errorf("found chunk with minTime: %d maxTime: %d outside of compacted minTime: %d maxTime: %d",
-					chk.MinTime, chk.MaxTime, meta.MinTime, meta.MaxTime)
-			}
-
-			if len(dranges) > 0 {
-				// Re-encode the chunk to not have deleted values.
-				if !chk.OverlapsClosedInterval(dranges[0].Mint, dranges[len(dranges)-1].Maxt) {
-					continue
-				}
-				newChunk := chunkenc.NewXORChunk()
-				app, err := newChunk.Appender()
-				if err != nil {
-					return err
-				}
-
-				delIter.it = chk.Chunk.Iterator(delIter.it)
-				delIter.intervals = dranges
-
-				var (
-					t int64
-					v float64
-				)
-				for delIter.Next() {
-					t, v = delIter.At()
-					app.Append(t, v)
-				}
-				if err := delIter.Err(); err != nil {
-					return errors.Wrap(err, "iterate chunk while re-encoding")
-				}
-
-				chks[i].Chunk = newChunk
-				chks[i].MaxTime = t
-			}
-		}
-
-		mergedChks := chks
-		if overlapping {
-			mergedChks, err = chunks.MergeOverlappingChunks(chks)
-			if err != nil {
-				return errors.Wrap(err, "merge overlapping chunks")
-			}
-		}
-		if err := chunkw.WriteChunks(mergedChks...); err != nil {
-			return errors.Wrap(err, "write chunks")
-		}
-
-		if err := indexw.AddSeries(i, lset, mergedChks...); err != nil {
-			return errors.Wrap(err, "add series")
-		}
-
-		meta.Stats.NumChunks += uint64(len(mergedChks))
-		meta.Stats.NumSeries++
-		for _, chk := range mergedChks {
-			meta.Stats.NumSamples += uint64(chk.Chunk.NumSamples())
-		}
-
-		for _, chk := range mergedChks {
-			if err := c.chunkPool.Put(chk.Chunk); err != nil {
-				return errors.Wrap(err, "put chunk")
-			}
-		}
-
-		for _, l := range lset {
-			valset, ok := values[l.Name]
-			if !ok {
-				valset = stringset{}
-				values[l.Name] = valset
-			}
-			valset.set(l.Value)
-		}
-		postings.Add(i, lset)
-
-		i++
-	}
-	if set.Err() != nil {
-		return errors.Wrap(set.Err(), "iterate compaction set")
-	}
-
-	s := make([]string, 0, 256)
-	for n, v := range values {
-		s = s[:0]
-
-		for x := range v {
-			s = append(s, x)
-		}
-		if err := indexw.WriteLabelIndex([]string{n}, s); err != nil {
-			return errors.Wrap(err, "write label index")
-		}
-	}
-
-	for _, l := range postings.SortedKeys() {
-		if err := indexw.WritePostings(l.Name, l.Value, postings.Get(l.Name, l.Value)); err != nil {
-			return errors.Wrap(err, "write postings")
-		}
-	}
-	return nil
-}
-
-type compactionSeriesSet struct {
-	p          index.Postings
-	index      IndexReader
-	chunks     ChunkReader
-	tombstones TombstoneReader
-
-	l         labels.Labels
-	c         []chunks.Meta
-	intervals Intervals
-	err       error
-}
-
-func newCompactionSeriesSet(i IndexReader, c ChunkReader, t TombstoneReader, p index.Postings) *compactionSeriesSet {
-	return &compactionSeriesSet{
-		index:      i,
-		chunks:     c,
-		tombstones: t,
-		p:          p,
-	}
-}
-
-func (c *compactionSeriesSet) Next() bool {
-	if !c.p.Next() {
-		return false
-	}
-	var err error
-
-	c.intervals, err = c.tombstones.Get(c.p.At())
-	if err != nil {
-		c.err = errors.Wrap(err, "get tombstones")
-		return false
-	}
-
-	if err = c.index.Series(c.p.At(), &c.l, &c.c); err != nil {
-		c.err = errors.Wrapf(err, "get series %d", c.p.At())
-		return false
-	}
-
-	// Remove completely deleted chunks.
-	if len(c.intervals) > 0 {
-		chks := make([]chunks.Meta, 0, len(c.c))
-		for _, chk := range c.c {
-			if !(Interval{chk.MinTime, chk.MaxTime}.isSubrange(c.intervals)) {
-				chks = append(chks, chk)
-			}
-		}
-
-		c.c = chks
-	}
-
-	for i := range c.c {
-		chk := &c.c[i]
-
-		chk.Chunk, err = c.chunks.Chunk(chk.Ref)
-		if err != nil {
-			c.err = errors.Wrapf(err, "chunk %d not found", chk.Ref)
-			return false
-		}
-	}
-
-	return true
-}
-
-func (c *compactionSeriesSet) Err() error {
-	if c.err != nil {
-		return c.err
-	}
-	return c.p.Err()
-}
-
-func (c *compactionSeriesSet) At() (labels.Labels, []chunks.Meta, Intervals) {
-	return c.l, c.c, c.intervals
-}
-
-type compactionMerger struct {
-	a, b ChunkSeriesSet
-
-	aok, bok  bool
-	l         labels.Labels
-	c         []chunks.Meta
-	intervals Intervals
-}
-
-func newCompactionMerger(a, b ChunkSeriesSet) (*compactionMerger, error) {
-	c := &compactionMerger{
-		a: a,
-		b: b,
-	}
-	// Initialize first elements of both sets as Next() needs
-	// one element look-ahead.
-	c.aok = c.a.Next()
-	c.bok = c.b.Next()
-
-	return c, c.Err()
-}
-
-func (c *compactionMerger) compare() int {
-	if !c.aok {
-		return 1
-	}
-	if !c.bok {
-		return -1
-	}
-	a, _, _ := c.a.At()
-	b, _, _ := c.b.At()
-	return labels.Compare(a, b)
-}
-
-func (c *compactionMerger) Next() bool {
-	if !c.aok && !c.bok || c.Err() != nil {
-		return false
-	}
-	// While advancing child iterators the memory used for labels and chunks
-	// may be reused. When picking a series we have to store the result.
-	var lset labels.Labels
-	var chks []chunks.Meta
-
-	d := c.compare()
-	if d > 0 {
-		lset, chks, c.intervals = c.b.At()
-		c.l = append(c.l[:0], lset...)
-		c.c = append(c.c[:0], chks...)
-
-		c.bok = c.b.Next()
-	} else if d < 0 {
-		lset, chks, c.intervals = c.a.At()
-		c.l = append(c.l[:0], lset...)
-		c.c = append(c.c[:0], chks...)
-
-		c.aok = c.a.Next()
-	} else {
-		// Both sets contain the current series. Chain them into a single one.
-		l, ca, ra := c.a.At()
-		_, cb, rb := c.b.At()
-
-		for _, r := range rb {
-			ra = ra.add(r)
-		}
-
-		c.l = append(c.l[:0], l...)
-		c.c = append(append(c.c[:0], ca...), cb...)
-		c.intervals = ra
-
-		c.aok = c.a.Next()
-		c.bok = c.b.Next()
-	}
-
-	return true
-}
-
-func (c *compactionMerger) Err() error {
-	if c.a.Err() != nil {
-		return c.a.Err()
-	}
-	return c.b.Err()
-}
-
-func (c *compactionMerger) At() (labels.Labels, []chunks.Meta, Intervals) {
-	return c.l, c.c, c.intervals
-}
diff --git a/vendor/github.com/prometheus/tsdb/db.go b/vendor/github.com/prometheus/tsdb/db.go
deleted file mode 100644
index aa9ec17857..0000000000
--- a/vendor/github.com/prometheus/tsdb/db.go
+++ /dev/null
@@ -1,1323 +0,0 @@
-// Copyright 2017 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.
-
-// Package tsdb implements a time series storage for float64 sample data.
-package tsdb
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"math"
-	"os"
-	"path/filepath"
-	"runtime"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
-	"github.com/oklog/ulid"
-	"github.com/pkg/errors"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/tsdb/chunkenc"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-	_ "github.com/prometheus/tsdb/goversion"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/wal"
-	"golang.org/x/sync/errgroup"
-)
-
-// DefaultOptions used for the DB. They are sane for setups using
-// millisecond precision timestamps.
-var DefaultOptions = &Options{
-	WALSegmentSize:         wal.DefaultSegmentSize,
-	RetentionDuration:      15 * 24 * 60 * 60 * 1000, // 15 days in milliseconds
-	BlockRanges:            ExponentialBlockRanges(int64(2*time.Hour)/1e6, 3, 5),
-	NoLockfile:             false,
-	AllowOverlappingBlocks: false,
-	WALCompression:         false,
-}
-
-// Options of the DB storage.
-type Options struct {
-	// Segments (wal files) max size.
-	// WALSegmentSize = 0, segment size is default size.
-	// WALSegmentSize > 0, segment size is WALSegmentSize.
-	// WALSegmentSize < 0, wal is disabled.
-	WALSegmentSize int
-
-	// Duration of persisted data to keep.
-	RetentionDuration uint64
-
-	// Maximum number of bytes in blocks to be retained.
-	// 0 or less means disabled.
-	// NOTE: For proper storage calculations need to consider
-	// the size of the WAL folder which is not added when calculating
-	// the current size of the database.
-	MaxBytes int64
-
-	// The sizes of the Blocks.
-	BlockRanges []int64
-
-	// NoLockfile disables creation and consideration of a lock file.
-	NoLockfile bool
-
-	// Overlapping blocks are allowed if AllowOverlappingBlocks is true.
-	// This in-turn enables vertical compaction and vertical query merge.
-	AllowOverlappingBlocks bool
-
-	// WALCompression will turn on Snappy compression for records on the WAL.
-	WALCompression bool
-}
-
-// Appender allows appending a batch of data. It must be completed with a
-// call to Commit or Rollback and must not be reused afterwards.
-//
-// Operations on the Appender interface are not goroutine-safe.
-type Appender interface {
-	// Add adds a sample pair for the given series. A reference number is
-	// returned which can be used to add further samples in the same or later
-	// transactions.
-	// Returned reference numbers are ephemeral and may be rejected in calls
-	// to AddFast() at any point. Adding the sample via Add() returns a new
-	// reference number.
-	// If the reference is 0 it must not be used for caching.
-	Add(l labels.Labels, t int64, v float64) (uint64, error)
-
-	// AddFast adds a sample pair for the referenced series. It is generally
-	// faster than adding a sample by providing its full label set.
-	AddFast(ref uint64, t int64, v float64) error
-
-	// Commit submits the collected samples and purges the batch.
-	Commit() error
-
-	// Rollback rolls back all modifications made in the appender so far.
-	Rollback() error
-}
-
-// DB handles reads and writes of time series falling into
-// a hashed partition of a seriedb.
-type DB struct {
-	dir   string
-	lockf fileutil.Releaser
-
-	logger    log.Logger
-	metrics   *dbMetrics
-	opts      *Options
-	chunkPool chunkenc.Pool
-	compactor Compactor
-
-	// Mutex for that must be held when modifying the general block layout.
-	mtx    sync.RWMutex
-	blocks []*Block
-
-	head *Head
-
-	compactc chan struct{}
-	donec    chan struct{}
-	stopc    chan struct{}
-
-	// cmtx ensures that compactions and deletions don't run simultaneously.
-	cmtx sync.Mutex
-
-	// autoCompactMtx ensures that no compaction gets triggered while
-	// changing the autoCompact var.
-	autoCompactMtx sync.Mutex
-	autoCompact    bool
-
-	// Cancel a running compaction when a shutdown is initiated.
-	compactCancel context.CancelFunc
-}
-
-type dbMetrics struct {
-	loadedBlocks         prometheus.GaugeFunc
-	symbolTableSize      prometheus.GaugeFunc
-	reloads              prometheus.Counter
-	reloadsFailed        prometheus.Counter
-	compactionsTriggered prometheus.Counter
-	compactionsFailed    prometheus.Counter
-	timeRetentionCount   prometheus.Counter
-	compactionsSkipped   prometheus.Counter
-	startTime            prometheus.GaugeFunc
-	tombCleanTimer       prometheus.Histogram
-	blocksBytes          prometheus.Gauge
-	sizeRetentionCount   prometheus.Counter
-}
-
-func newDBMetrics(db *DB, r prometheus.Registerer) *dbMetrics {
-	m := &dbMetrics{}
-
-	m.loadedBlocks = prometheus.NewGaugeFunc(prometheus.GaugeOpts{
-		Name: "prometheus_tsdb_blocks_loaded",
-		Help: "Number of currently loaded data blocks",
-	}, func() float64 {
-		db.mtx.RLock()
-		defer db.mtx.RUnlock()
-		return float64(len(db.blocks))
-	})
-	m.symbolTableSize = prometheus.NewGaugeFunc(prometheus.GaugeOpts{
-		Name: "prometheus_tsdb_symbol_table_size_bytes",
-		Help: "Size of symbol table on disk (in bytes)",
-	}, func() float64 {
-		db.mtx.RLock()
-		blocks := db.blocks[:]
-		db.mtx.RUnlock()
-		symTblSize := uint64(0)
-		for _, b := range blocks {
-			symTblSize += b.GetSymbolTableSize()
-		}
-		return float64(symTblSize)
-	})
-	m.reloads = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_reloads_total",
-		Help: "Number of times the database reloaded block data from disk.",
-	})
-	m.reloadsFailed = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_reloads_failures_total",
-		Help: "Number of times the database failed to reload block data from disk.",
-	})
-	m.compactionsTriggered = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_compactions_triggered_total",
-		Help: "Total number of triggered compactions for the partition.",
-	})
-	m.compactionsFailed = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_compactions_failed_total",
-		Help: "Total number of compactions that failed for the partition.",
-	})
-	m.timeRetentionCount = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_time_retentions_total",
-		Help: "The number of times that blocks were deleted because the maximum time limit was exceeded.",
-	})
-	m.compactionsSkipped = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_compactions_skipped_total",
-		Help: "Total number of skipped compactions due to disabled auto compaction.",
-	})
-	m.startTime = prometheus.NewGaugeFunc(prometheus.GaugeOpts{
-		Name: "prometheus_tsdb_lowest_timestamp",
-		Help: "Lowest timestamp value stored in the database. The unit is decided by the library consumer.",
-	}, func() float64 {
-		db.mtx.RLock()
-		defer db.mtx.RUnlock()
-		if len(db.blocks) == 0 {
-			return float64(db.head.minTime)
-		}
-		return float64(db.blocks[0].meta.MinTime)
-	})
-	m.tombCleanTimer = prometheus.NewHistogram(prometheus.HistogramOpts{
-		Name: "prometheus_tsdb_tombstone_cleanup_seconds",
-		Help: "The time taken to recompact blocks to remove tombstones.",
-	})
-	m.blocksBytes = prometheus.NewGauge(prometheus.GaugeOpts{
-		Name: "prometheus_tsdb_storage_blocks_bytes",
-		Help: "The number of bytes that are currently used for local storage by all blocks.",
-	})
-	m.sizeRetentionCount = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_size_retentions_total",
-		Help: "The number of times that blocks were deleted because the maximum number of bytes was exceeded.",
-	})
-
-	if r != nil {
-		r.MustRegister(
-			m.loadedBlocks,
-			m.symbolTableSize,
-			m.reloads,
-			m.reloadsFailed,
-			m.timeRetentionCount,
-			m.compactionsTriggered,
-			m.compactionsFailed,
-			m.startTime,
-			m.tombCleanTimer,
-			m.blocksBytes,
-			m.sizeRetentionCount,
-		)
-	}
-	return m
-}
-
-// ErrClosed is returned when the db is closed.
-var ErrClosed = errors.New("db already closed")
-
-// DBReadOnly provides APIs for read only operations on a database.
-// Current implementation doesn't support concurency so
-// all API calls should happen in the same go routine.
-type DBReadOnly struct {
-	logger  log.Logger
-	dir     string
-	closers []io.Closer
-	closed  chan struct{}
-}
-
-// OpenDBReadOnly opens DB in the given directory for read only operations.
-func OpenDBReadOnly(dir string, l log.Logger) (*DBReadOnly, error) {
-	if _, err := os.Stat(dir); err != nil {
-		return nil, errors.Wrap(err, "openning the db dir")
-	}
-
-	if l == nil {
-		l = log.NewNopLogger()
-	}
-
-	return &DBReadOnly{
-		logger: l,
-		dir:    dir,
-		closed: make(chan struct{}),
-	}, nil
-}
-
-// Querier loads the wal and returns a new querier over the data partition for the given time range.
-// Current implementation doesn't support multiple Queriers.
-func (db *DBReadOnly) Querier(mint, maxt int64) (Querier, error) {
-	select {
-	case <-db.closed:
-		return nil, ErrClosed
-	default:
-	}
-	blocksReaders, err := db.Blocks()
-	if err != nil {
-		return nil, err
-	}
-	blocks := make([]*Block, len(blocksReaders))
-	for i, b := range blocksReaders {
-		b, ok := b.(*Block)
-		if !ok {
-			return nil, errors.New("unable to convert a read only block to a normal block")
-		}
-		blocks[i] = b
-	}
-
-	head, err := NewHead(nil, db.logger, nil, 1)
-	if err != nil {
-		return nil, err
-	}
-	maxBlockTime := int64(math.MinInt64)
-	if len(blocks) > 0 {
-		maxBlockTime = blocks[len(blocks)-1].Meta().MaxTime
-	}
-
-	// Also add the WAL if the current blocks don't cover the requestes time range.
-	if maxBlockTime <= maxt {
-		w, err := wal.Open(db.logger, nil, filepath.Join(db.dir, "wal"))
-		if err != nil {
-			return nil, err
-		}
-		head, err = NewHead(nil, db.logger, w, 1)
-		if err != nil {
-			return nil, err
-		}
-		// Set the min valid time for the ingested wal samples
-		// to be no lower than the maxt of the last block.
-		if err := head.Init(maxBlockTime); err != nil {
-			return nil, errors.Wrap(err, "read WAL")
-		}
-		// Set the wal to nil to disable all wal operations.
-		// This is mainly to avoid blocking when closing the head.
-		head.wal = nil
-
-		db.closers = append(db.closers, head)
-	}
-
-	// TODO: Refactor so that it is possible to obtain a Querier without initializing a writable DB instance.
-	// Option 1: refactor DB to have the Querier implementation using the DBReadOnly.Querier implementation not the opposite.
-	// Option 2: refactor Querier to use another independent func which
-	// can than be used by a read only and writable db instances without any code duplication.
-	dbWritable := &DB{
-		dir:    db.dir,
-		logger: db.logger,
-		blocks: blocks,
-		head:   head,
-	}
-
-	return dbWritable.Querier(mint, maxt)
-}
-
-// Blocks returns a slice of block readers for persisted blocks.
-func (db *DBReadOnly) Blocks() ([]BlockReader, error) {
-	select {
-	case <-db.closed:
-		return nil, ErrClosed
-	default:
-	}
-	loadable, corrupted, err := openBlocks(db.logger, db.dir, nil, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	// Corrupted blocks that have been superseded by a loadable block can be safely ignored.
-	for _, block := range loadable {
-		for _, b := range block.Meta().Compaction.Parents {
-			delete(corrupted, b.ULID)
-		}
-	}
-	if len(corrupted) > 0 {
-		for _, b := range loadable {
-			if err := b.Close(); err != nil {
-				level.Warn(db.logger).Log("msg", "closing a block", err)
-			}
-		}
-		return nil, errors.Errorf("unexpected corrupted block:%v", corrupted)
-	}
-
-	if len(loadable) == 0 {
-		return nil, errors.New("no blocks found")
-	}
-
-	sort.Slice(loadable, func(i, j int) bool {
-		return loadable[i].Meta().MinTime < loadable[j].Meta().MinTime
-	})
-
-	blockMetas := make([]BlockMeta, 0, len(loadable))
-	for _, b := range loadable {
-		blockMetas = append(blockMetas, b.Meta())
-	}
-	if overlaps := OverlappingBlocks(blockMetas); len(overlaps) > 0 {
-		level.Warn(db.logger).Log("msg", "overlapping blocks found during opening", "detail", overlaps.String())
-	}
-
-	// Close all previously open readers and add the new ones to the cache.
-	for _, closer := range db.closers {
-		closer.Close()
-	}
-
-	blockClosers := make([]io.Closer, len(loadable))
-	blockReaders := make([]BlockReader, len(loadable))
-	for i, b := range loadable {
-		blockClosers[i] = b
-		blockReaders[i] = b
-	}
-	db.closers = blockClosers
-
-	return blockReaders, nil
-}
-
-// Close all block readers.
-func (db *DBReadOnly) Close() error {
-	select {
-	case <-db.closed:
-		return ErrClosed
-	default:
-	}
-	close(db.closed)
-
-	var merr tsdb_errors.MultiError
-
-	for _, b := range db.closers {
-		merr.Add(b.Close())
-	}
-	return merr.Err()
-}
-
-// Open returns a new DB in the given directory.
-func Open(dir string, l log.Logger, r prometheus.Registerer, opts *Options) (db *DB, err error) {
-	if err := os.MkdirAll(dir, 0777); err != nil {
-		return nil, err
-	}
-	if l == nil {
-		l = log.NewNopLogger()
-	}
-	if opts == nil {
-		opts = DefaultOptions
-	}
-	// Fixup bad format written by Prometheus 2.1.
-	if err := repairBadIndexVersion(l, dir); err != nil {
-		return nil, err
-	}
-	// Migrate old WAL if one exists.
-	if err := MigrateWAL(l, filepath.Join(dir, "wal")); err != nil {
-		return nil, errors.Wrap(err, "migrate WAL")
-	}
-
-	db = &DB{
-		dir:         dir,
-		logger:      l,
-		opts:        opts,
-		compactc:    make(chan struct{}, 1),
-		donec:       make(chan struct{}),
-		stopc:       make(chan struct{}),
-		autoCompact: true,
-		chunkPool:   chunkenc.NewPool(),
-	}
-	db.metrics = newDBMetrics(db, r)
-
-	if !opts.NoLockfile {
-		absdir, err := filepath.Abs(dir)
-		if err != nil {
-			return nil, err
-		}
-		lockf, _, err := fileutil.Flock(filepath.Join(absdir, "lock"))
-		if err != nil {
-			return nil, errors.Wrap(err, "lock DB directory")
-		}
-		db.lockf = lockf
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	db.compactor, err = NewLeveledCompactor(ctx, r, l, opts.BlockRanges, db.chunkPool)
-	if err != nil {
-		cancel()
-		return nil, errors.Wrap(err, "create leveled compactor")
-	}
-	db.compactCancel = cancel
-
-	var wlog *wal.WAL
-	segmentSize := wal.DefaultSegmentSize
-	// Wal is enabled.
-	if opts.WALSegmentSize >= 0 {
-		// Wal is set to a custom size.
-		if opts.WALSegmentSize > 0 {
-			segmentSize = opts.WALSegmentSize
-		}
-		wlog, err = wal.NewSize(l, r, filepath.Join(dir, "wal"), segmentSize, opts.WALCompression)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	db.head, err = NewHead(r, l, wlog, opts.BlockRanges[0])
-	if err != nil {
-		return nil, err
-	}
-
-	if err := db.reload(); err != nil {
-		return nil, err
-	}
-	// Set the min valid time for the ingested samples
-	// to be no lower than the maxt of the last block.
-	blocks := db.Blocks()
-	minValidTime := int64(math.MinInt64)
-	if len(blocks) > 0 {
-		minValidTime = blocks[len(blocks)-1].Meta().MaxTime
-	}
-
-	if initErr := db.head.Init(minValidTime); initErr != nil {
-		db.head.metrics.walCorruptionsTotal.Inc()
-		level.Warn(db.logger).Log("msg", "encountered WAL read error, attempting repair", "err", err)
-		if err := wlog.Repair(initErr); err != nil {
-			return nil, errors.Wrap(err, "repair corrupted WAL")
-		}
-	}
-
-	go db.run()
-
-	return db, nil
-}
-
-// Dir returns the directory of the database.
-func (db *DB) Dir() string {
-	return db.dir
-}
-
-func (db *DB) run() {
-	defer close(db.donec)
-
-	backoff := time.Duration(0)
-
-	for {
-		select {
-		case <-db.stopc:
-			return
-		case <-time.After(backoff):
-		}
-
-		select {
-		case <-time.After(1 * time.Minute):
-			select {
-			case db.compactc <- struct{}{}:
-			default:
-			}
-		case <-db.compactc:
-			db.metrics.compactionsTriggered.Inc()
-
-			db.autoCompactMtx.Lock()
-			if db.autoCompact {
-				if err := db.compact(); err != nil {
-					level.Error(db.logger).Log("msg", "compaction failed", "err", err)
-					backoff = exponential(backoff, 1*time.Second, 1*time.Minute)
-				} else {
-					backoff = 0
-				}
-			} else {
-				db.metrics.compactionsSkipped.Inc()
-			}
-			db.autoCompactMtx.Unlock()
-		case <-db.stopc:
-			return
-		}
-	}
-}
-
-// Appender opens a new appender against the database.
-func (db *DB) Appender() Appender {
-	return dbAppender{db: db, Appender: db.head.Appender()}
-}
-
-// dbAppender wraps the DB's head appender and triggers compactions on commit
-// if necessary.
-type dbAppender struct {
-	Appender
-	db *DB
-}
-
-func (a dbAppender) Commit() error {
-	err := a.Appender.Commit()
-
-	// We could just run this check every few minutes practically. But for benchmarks
-	// and high frequency use cases this is the safer way.
-	if a.db.head.compactable() {
-		select {
-		case a.db.compactc <- struct{}{}:
-		default:
-		}
-	}
-	return err
-}
-
-// Compact data if possible. After successful compaction blocks are reloaded
-// which will also trigger blocks to be deleted that fall out of the retention
-// window.
-// If no blocks are compacted, the retention window state doesn't change. Thus,
-// this is sufficient to reliably delete old data.
-// Old blocks are only deleted on reload based on the new block's parent information.
-// See DB.reload documentation for further information.
-func (db *DB) compact() (err error) {
-	db.cmtx.Lock()
-	defer db.cmtx.Unlock()
-	defer func() {
-		if err != nil {
-			db.metrics.compactionsFailed.Inc()
-		}
-	}()
-	// Check whether we have pending head blocks that are ready to be persisted.
-	// They have the highest priority.
-	for {
-		select {
-		case <-db.stopc:
-			return nil
-		default:
-		}
-		if !db.head.compactable() {
-			break
-		}
-		mint := db.head.MinTime()
-		maxt := rangeForTimestamp(mint, db.head.chunkRange)
-
-		// Wrap head into a range that bounds all reads to it.
-		head := &rangeHead{
-			head: db.head,
-			mint: mint,
-			// We remove 1 millisecond from maxt because block
-			// intervals are half-open: [b.MinTime, b.MaxTime). But
-			// chunk intervals are closed: [c.MinTime, c.MaxTime];
-			// so in order to make sure that overlaps are evaluated
-			// consistently, we explicitly remove the last value
-			// from the block interval here.
-			maxt: maxt - 1,
-		}
-		uid, err := db.compactor.Write(db.dir, head, mint, maxt, nil)
-		if err != nil {
-			return errors.Wrap(err, "persist head block")
-		}
-
-		runtime.GC()
-
-		if err := db.reload(); err != nil {
-			if err := os.RemoveAll(filepath.Join(db.dir, uid.String())); err != nil {
-				return errors.Wrapf(err, "delete persisted head block after failed db reload:%s", uid)
-			}
-			return errors.Wrap(err, "reload blocks")
-		}
-		if (uid == ulid.ULID{}) {
-			// Compaction resulted in an empty block.
-			// Head truncating during db.reload() depends on the persisted blocks and
-			// in this case no new block will be persisted so manually truncate the head.
-			if err = db.head.Truncate(maxt); err != nil {
-				return errors.Wrap(err, "head truncate failed (in compact)")
-			}
-		}
-		runtime.GC()
-	}
-
-	// Check for compactions of multiple blocks.
-	for {
-		plan, err := db.compactor.Plan(db.dir)
-		if err != nil {
-			return errors.Wrap(err, "plan compaction")
-		}
-		if len(plan) == 0 {
-			break
-		}
-
-		select {
-		case <-db.stopc:
-			return nil
-		default:
-		}
-
-		uid, err := db.compactor.Compact(db.dir, plan, db.blocks)
-		if err != nil {
-			return errors.Wrapf(err, "compact %s", plan)
-		}
-		runtime.GC()
-
-		if err := db.reload(); err != nil {
-			if err := os.RemoveAll(filepath.Join(db.dir, uid.String())); err != nil {
-				return errors.Wrapf(err, "delete compacted block after failed db reload:%s", uid)
-			}
-			return errors.Wrap(err, "reload blocks")
-		}
-		runtime.GC()
-	}
-
-	return nil
-}
-
-// getBlock iterates a given block range to find a block by a given id.
-// If found it returns the block itself and a boolean to indicate that it was found.
-func getBlock(allBlocks []*Block, id ulid.ULID) (*Block, bool) {
-	for _, b := range allBlocks {
-		if b.Meta().ULID == id {
-			return b, true
-		}
-	}
-	return nil, false
-}
-
-// reload blocks and trigger head truncation if new blocks appeared.
-// Blocks that are obsolete due to replacement or retention will be deleted.
-func (db *DB) reload() (err error) {
-	defer func() {
-		if err != nil {
-			db.metrics.reloadsFailed.Inc()
-		}
-		db.metrics.reloads.Inc()
-	}()
-
-	loadable, corrupted, err := openBlocks(db.logger, db.dir, db.blocks, db.chunkPool)
-	if err != nil {
-		return err
-	}
-
-	deletable := db.deletableBlocks(loadable)
-
-	// Corrupted blocks that have been superseded by a loadable block can be safely ignored.
-	// This makes it resilient against the process crashing towards the end of a compaction.
-	// Creation of a new block and deletion of its parents cannot happen atomically.
-	// By creating blocks with their parents, we can pick up the deletion where it left off during a crash.
-	for _, block := range loadable {
-		for _, b := range block.Meta().Compaction.Parents {
-			delete(corrupted, b.ULID)
-			deletable[b.ULID] = nil
-		}
-	}
-	if len(corrupted) > 0 {
-		// Close all new blocks to release the lock for windows.
-		for _, block := range loadable {
-			if _, open := getBlock(db.blocks, block.Meta().ULID); !open {
-				block.Close()
-			}
-		}
-		return fmt.Errorf("unexpected corrupted block:%v", corrupted)
-	}
-
-	// All deletable blocks should not be loaded.
-	var (
-		bb         []*Block
-		blocksSize int64
-	)
-	for _, block := range loadable {
-		if _, ok := deletable[block.Meta().ULID]; ok {
-			deletable[block.Meta().ULID] = block
-			continue
-		}
-		bb = append(bb, block)
-		blocksSize += block.Size()
-
-	}
-	loadable = bb
-	db.metrics.blocksBytes.Set(float64(blocksSize))
-
-	sort.Slice(loadable, func(i, j int) bool {
-		return loadable[i].Meta().MinTime < loadable[j].Meta().MinTime
-	})
-	if !db.opts.AllowOverlappingBlocks {
-		if err := validateBlockSequence(loadable); err != nil {
-			return errors.Wrap(err, "invalid block sequence")
-		}
-	}
-
-	// Swap new blocks first for subsequently created readers to be seen.
-	db.mtx.Lock()
-	oldBlocks := db.blocks
-	db.blocks = loadable
-	db.mtx.Unlock()
-
-	blockMetas := make([]BlockMeta, 0, len(loadable))
-	for _, b := range loadable {
-		blockMetas = append(blockMetas, b.Meta())
-	}
-	if overlaps := OverlappingBlocks(blockMetas); len(overlaps) > 0 {
-		level.Warn(db.logger).Log("msg", "overlapping blocks found during reload", "detail", overlaps.String())
-	}
-
-	for _, b := range oldBlocks {
-		if _, ok := deletable[b.Meta().ULID]; ok {
-			deletable[b.Meta().ULID] = b
-		}
-	}
-
-	if err := db.deleteBlocks(deletable); err != nil {
-		return err
-	}
-
-	// Garbage collect data in the head if the most recent persisted block
-	// covers data of its current time range.
-	if len(loadable) == 0 {
-		return nil
-	}
-
-	maxt := loadable[len(loadable)-1].Meta().MaxTime
-
-	return errors.Wrap(db.head.Truncate(maxt), "head truncate failed")
-}
-
-func openBlocks(l log.Logger, dir string, loaded []*Block, chunkPool chunkenc.Pool) (blocks []*Block, corrupted map[ulid.ULID]error, err error) {
-	bDirs, err := blockDirs(dir)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "find blocks")
-	}
-
-	corrupted = make(map[ulid.ULID]error)
-	for _, bDir := range bDirs {
-		meta, _, err := readMetaFile(bDir)
-		if err != nil {
-			level.Error(l).Log("msg", "not a block dir", "dir", bDir)
-			continue
-		}
-
-		// See if we already have the block in memory or open it otherwise.
-		block, open := getBlock(loaded, meta.ULID)
-		if !open {
-			block, err = OpenBlock(l, bDir, chunkPool)
-			if err != nil {
-				corrupted[meta.ULID] = err
-				continue
-			}
-		}
-		blocks = append(blocks, block)
-	}
-	return blocks, corrupted, nil
-}
-
-// deletableBlocks returns all blocks past retention policy.
-func (db *DB) deletableBlocks(blocks []*Block) map[ulid.ULID]*Block {
-	deletable := make(map[ulid.ULID]*Block)
-
-	// Sort the blocks by time - newest to oldest (largest to smallest timestamp).
-	// This ensures that the retentions will remove the oldest  blocks.
-	sort.Slice(blocks, func(i, j int) bool {
-		return blocks[i].Meta().MaxTime > blocks[j].Meta().MaxTime
-	})
-
-	for _, block := range blocks {
-		if block.Meta().Compaction.Deletable {
-			deletable[block.Meta().ULID] = block
-		}
-	}
-
-	for ulid, block := range db.beyondTimeRetention(blocks) {
-		deletable[ulid] = block
-	}
-
-	for ulid, block := range db.beyondSizeRetention(blocks) {
-		deletable[ulid] = block
-	}
-
-	return deletable
-}
-
-func (db *DB) beyondTimeRetention(blocks []*Block) (deleteable map[ulid.ULID]*Block) {
-	// Time retention is disabled or no blocks to work with.
-	if len(db.blocks) == 0 || db.opts.RetentionDuration == 0 {
-		return
-	}
-
-	deleteable = make(map[ulid.ULID]*Block)
-	for i, block := range blocks {
-		// The difference between the first block and this block is larger than
-		// the retention period so any blocks after that are added as deleteable.
-		if i > 0 && blocks[0].Meta().MaxTime-block.Meta().MaxTime > int64(db.opts.RetentionDuration) {
-			for _, b := range blocks[i:] {
-				deleteable[b.meta.ULID] = b
-			}
-			db.metrics.timeRetentionCount.Inc()
-			break
-		}
-	}
-	return deleteable
-}
-
-func (db *DB) beyondSizeRetention(blocks []*Block) (deleteable map[ulid.ULID]*Block) {
-	// Size retention is disabled or no blocks to work with.
-	if len(db.blocks) == 0 || db.opts.MaxBytes <= 0 {
-		return
-	}
-
-	deleteable = make(map[ulid.ULID]*Block)
-	blocksSize := int64(0)
-	for i, block := range blocks {
-		blocksSize += block.Size()
-		if blocksSize > db.opts.MaxBytes {
-			// Add this and all following blocks for deletion.
-			for _, b := range blocks[i:] {
-				deleteable[b.meta.ULID] = b
-			}
-			db.metrics.sizeRetentionCount.Inc()
-			break
-		}
-	}
-	return deleteable
-}
-
-// deleteBlocks closes and deletes blocks from the disk.
-// When the map contains a non nil block object it means it is loaded in memory
-// so needs to be closed first as it might need to wait for pending readers to complete.
-func (db *DB) deleteBlocks(blocks map[ulid.ULID]*Block) error {
-	for ulid, block := range blocks {
-		if block != nil {
-			if err := block.Close(); err != nil {
-				level.Warn(db.logger).Log("msg", "closing block failed", "err", err)
-			}
-		}
-		if err := os.RemoveAll(filepath.Join(db.dir, ulid.String())); err != nil {
-			return errors.Wrapf(err, "delete obsolete block %s", ulid)
-		}
-	}
-	return nil
-}
-
-// validateBlockSequence returns error if given block meta files indicate that some blocks overlaps within sequence.
-func validateBlockSequence(bs []*Block) error {
-	if len(bs) <= 1 {
-		return nil
-	}
-
-	var metas []BlockMeta
-	for _, b := range bs {
-		metas = append(metas, b.meta)
-	}
-
-	overlaps := OverlappingBlocks(metas)
-	if len(overlaps) > 0 {
-		return errors.Errorf("block time ranges overlap: %s", overlaps)
-	}
-
-	return nil
-}
-
-// TimeRange specifies minTime and maxTime range.
-type TimeRange struct {
-	Min, Max int64
-}
-
-// Overlaps contains overlapping blocks aggregated by overlapping range.
-type Overlaps map[TimeRange][]BlockMeta
-
-// String returns human readable string form of overlapped blocks.
-func (o Overlaps) String() string {
-	var res []string
-	for r, overlaps := range o {
-		var groups []string
-		for _, m := range overlaps {
-			groups = append(groups, fmt.Sprintf(
-				"<ulid: %s, mint: %d, maxt: %d, range: %s>",
-				m.ULID.String(),
-				m.MinTime,
-				m.MaxTime,
-				(time.Duration((m.MaxTime-m.MinTime)/1000)*time.Second).String(),
-			))
-		}
-		res = append(res, fmt.Sprintf(
-			"[mint: %d, maxt: %d, range: %s, blocks: %d]: %s",
-			r.Min, r.Max,
-			(time.Duration((r.Max-r.Min)/1000)*time.Second).String(),
-			len(overlaps),
-			strings.Join(groups, ", ")),
-		)
-	}
-	return strings.Join(res, "\n")
-}
-
-// OverlappingBlocks returns all overlapping blocks from given meta files.
-func OverlappingBlocks(bm []BlockMeta) Overlaps {
-	if len(bm) <= 1 {
-		return nil
-	}
-	var (
-		overlaps [][]BlockMeta
-
-		// pending contains not ended blocks in regards to "current" timestamp.
-		pending = []BlockMeta{bm[0]}
-		// continuousPending helps to aggregate same overlaps to single group.
-		continuousPending = true
-	)
-
-	// We have here blocks sorted by minTime. We iterate over each block and treat its minTime as our "current" timestamp.
-	// We check if any of the pending block finished (blocks that we have seen before, but their maxTime was still ahead current
-	// timestamp). If not, it means they overlap with our current block. In the same time current block is assumed pending.
-	for _, b := range bm[1:] {
-		var newPending []BlockMeta
-
-		for _, p := range pending {
-			// "b.MinTime" is our current time.
-			if b.MinTime >= p.MaxTime {
-				continuousPending = false
-				continue
-			}
-
-			// "p" overlaps with "b" and "p" is still pending.
-			newPending = append(newPending, p)
-		}
-
-		// Our block "b" is now pending.
-		pending = append(newPending, b)
-		if len(newPending) == 0 {
-			// No overlaps.
-			continue
-		}
-
-		if continuousPending && len(overlaps) > 0 {
-			overlaps[len(overlaps)-1] = append(overlaps[len(overlaps)-1], b)
-			continue
-		}
-		overlaps = append(overlaps, append(newPending, b))
-		// Start new pendings.
-		continuousPending = true
-	}
-
-	// Fetch the critical overlapped time range foreach overlap groups.
-	overlapGroups := Overlaps{}
-	for _, overlap := range overlaps {
-
-		minRange := TimeRange{Min: 0, Max: math.MaxInt64}
-		for _, b := range overlap {
-			if minRange.Max > b.MaxTime {
-				minRange.Max = b.MaxTime
-			}
-
-			if minRange.Min < b.MinTime {
-				minRange.Min = b.MinTime
-			}
-		}
-		overlapGroups[minRange] = overlap
-	}
-
-	return overlapGroups
-}
-
-func (db *DB) String() string {
-	return "HEAD"
-}
-
-// Blocks returns the databases persisted blocks.
-func (db *DB) Blocks() []*Block {
-	db.mtx.RLock()
-	defer db.mtx.RUnlock()
-
-	return db.blocks
-}
-
-// Head returns the databases's head.
-func (db *DB) Head() *Head {
-	return db.head
-}
-
-// Close the partition.
-func (db *DB) Close() error {
-	close(db.stopc)
-	db.compactCancel()
-	<-db.donec
-
-	db.mtx.Lock()
-	defer db.mtx.Unlock()
-
-	var g errgroup.Group
-
-	// blocks also contains all head blocks.
-	for _, pb := range db.blocks {
-		g.Go(pb.Close)
-	}
-
-	var merr tsdb_errors.MultiError
-
-	merr.Add(g.Wait())
-
-	if db.lockf != nil {
-		merr.Add(db.lockf.Release())
-	}
-	merr.Add(db.head.Close())
-	return merr.Err()
-}
-
-// DisableCompactions disables auto compactions.
-func (db *DB) DisableCompactions() {
-	db.autoCompactMtx.Lock()
-	defer db.autoCompactMtx.Unlock()
-
-	db.autoCompact = false
-	level.Info(db.logger).Log("msg", "compactions disabled")
-}
-
-// EnableCompactions enables auto compactions.
-func (db *DB) EnableCompactions() {
-	db.autoCompactMtx.Lock()
-	defer db.autoCompactMtx.Unlock()
-
-	db.autoCompact = true
-	level.Info(db.logger).Log("msg", "compactions enabled")
-}
-
-// Snapshot writes the current data to the directory. If withHead is set to true it
-// will create a new block containing all data that's currently in the memory buffer/WAL.
-func (db *DB) Snapshot(dir string, withHead bool) error {
-	if dir == db.dir {
-		return errors.Errorf("cannot snapshot into base directory")
-	}
-	if _, err := ulid.ParseStrict(dir); err == nil {
-		return errors.Errorf("dir must not be a valid ULID")
-	}
-
-	db.cmtx.Lock()
-	defer db.cmtx.Unlock()
-
-	db.mtx.RLock()
-	defer db.mtx.RUnlock()
-
-	for _, b := range db.blocks {
-		level.Info(db.logger).Log("msg", "snapshotting block", "block", b)
-
-		if err := b.Snapshot(dir); err != nil {
-			return errors.Wrapf(err, "error snapshotting block: %s", b.Dir())
-		}
-	}
-	if !withHead {
-		return nil
-	}
-
-	mint := db.head.MinTime()
-	maxt := db.head.MaxTime()
-	head := &rangeHead{
-		head: db.head,
-		mint: mint,
-		maxt: maxt,
-	}
-	// Add +1 millisecond to block maxt because block intervals are half-open: [b.MinTime, b.MaxTime).
-	// Because of this block intervals are always +1 than the total samples it includes.
-	if _, err := db.compactor.Write(dir, head, mint, maxt+1, nil); err != nil {
-		return errors.Wrap(err, "snapshot head block")
-	}
-	return nil
-}
-
-// Querier returns a new querier over the data partition for the given time range.
-// A goroutine must not handle more than one open Querier.
-func (db *DB) Querier(mint, maxt int64) (Querier, error) {
-	var blocks []BlockReader
-	var blockMetas []BlockMeta
-
-	db.mtx.RLock()
-	defer db.mtx.RUnlock()
-
-	for _, b := range db.blocks {
-		if b.OverlapsClosedInterval(mint, maxt) {
-			blocks = append(blocks, b)
-			blockMetas = append(blockMetas, b.Meta())
-		}
-	}
-	if maxt >= db.head.MinTime() {
-		blocks = append(blocks, &rangeHead{
-			head: db.head,
-			mint: mint,
-			maxt: maxt,
-		})
-	}
-
-	blockQueriers := make([]Querier, 0, len(blocks))
-	for _, b := range blocks {
-		q, err := NewBlockQuerier(b, mint, maxt)
-		if err == nil {
-			blockQueriers = append(blockQueriers, q)
-			continue
-		}
-		// If we fail, all previously opened queriers must be closed.
-		for _, q := range blockQueriers {
-			q.Close()
-		}
-		return nil, errors.Wrapf(err, "open querier for block %s", b)
-	}
-
-	if len(OverlappingBlocks(blockMetas)) > 0 {
-		return &verticalQuerier{
-			querier: querier{
-				blocks: blockQueriers,
-			},
-		}, nil
-	}
-
-	return &querier{
-		blocks: blockQueriers,
-	}, nil
-}
-
-func rangeForTimestamp(t int64, width int64) (maxt int64) {
-	return (t/width)*width + width
-}
-
-// Delete implements deletion of metrics. It only has atomicity guarantees on a per-block basis.
-func (db *DB) Delete(mint, maxt int64, ms ...labels.Matcher) error {
-	db.cmtx.Lock()
-	defer db.cmtx.Unlock()
-
-	var g errgroup.Group
-
-	db.mtx.RLock()
-	defer db.mtx.RUnlock()
-
-	for _, b := range db.blocks {
-		if b.OverlapsClosedInterval(mint, maxt) {
-			g.Go(func(b *Block) func() error {
-				return func() error { return b.Delete(mint, maxt, ms...) }
-			}(b))
-		}
-	}
-	g.Go(func() error {
-		return db.head.Delete(mint, maxt, ms...)
-	})
-	return g.Wait()
-}
-
-// CleanTombstones re-writes any blocks with tombstones.
-func (db *DB) CleanTombstones() (err error) {
-	db.cmtx.Lock()
-	defer db.cmtx.Unlock()
-
-	start := time.Now()
-	defer db.metrics.tombCleanTimer.Observe(time.Since(start).Seconds())
-
-	newUIDs := []ulid.ULID{}
-	defer func() {
-		// If any error is caused, we need to delete all the new directory created.
-		if err != nil {
-			for _, uid := range newUIDs {
-				dir := filepath.Join(db.Dir(), uid.String())
-				if err := os.RemoveAll(dir); err != nil {
-					level.Error(db.logger).Log("msg", "failed to delete block after failed `CleanTombstones`", "dir", dir, "err", err)
-				}
-			}
-		}
-	}()
-
-	db.mtx.RLock()
-	blocks := db.blocks[:]
-	db.mtx.RUnlock()
-
-	for _, b := range blocks {
-		if uid, er := b.CleanTombstones(db.Dir(), db.compactor); er != nil {
-			err = errors.Wrapf(er, "clean tombstones: %s", b.Dir())
-			return err
-		} else if uid != nil { // New block was created.
-			newUIDs = append(newUIDs, *uid)
-		}
-	}
-	return errors.Wrap(db.reload(), "reload blocks")
-}
-
-func isBlockDir(fi os.FileInfo) bool {
-	if !fi.IsDir() {
-		return false
-	}
-	_, err := ulid.ParseStrict(fi.Name())
-	return err == nil
-}
-
-func blockDirs(dir string) ([]string, error) {
-	files, err := ioutil.ReadDir(dir)
-	if err != nil {
-		return nil, err
-	}
-	var dirs []string
-
-	for _, fi := range files {
-		if isBlockDir(fi) {
-			dirs = append(dirs, filepath.Join(dir, fi.Name()))
-		}
-	}
-	return dirs, nil
-}
-
-func sequenceFiles(dir string) ([]string, error) {
-	files, err := ioutil.ReadDir(dir)
-	if err != nil {
-		return nil, err
-	}
-	var res []string
-
-	for _, fi := range files {
-		if _, err := strconv.ParseUint(fi.Name(), 10, 64); err != nil {
-			continue
-		}
-		res = append(res, filepath.Join(dir, fi.Name()))
-	}
-	return res, nil
-}
-
-func nextSequenceFile(dir string) (string, int, error) {
-	names, err := fileutil.ReadDir(dir)
-	if err != nil {
-		return "", 0, err
-	}
-
-	i := uint64(0)
-	for _, n := range names {
-		j, err := strconv.ParseUint(n, 10, 64)
-		if err != nil {
-			continue
-		}
-		i = j
-	}
-	return filepath.Join(dir, fmt.Sprintf("%0.6d", i+1)), int(i + 1), nil
-}
-
-func closeAll(cs []io.Closer) error {
-	var merr tsdb_errors.MultiError
-
-	for _, c := range cs {
-		merr.Add(c.Close())
-	}
-	return merr.Err()
-}
-
-func exponential(d, min, max time.Duration) time.Duration {
-	d *= 2
-	if d < min {
-		d = min
-	}
-	if d > max {
-		d = max
-	}
-	return d
-}
diff --git a/vendor/github.com/prometheus/tsdb/encoding/encoding.go b/vendor/github.com/prometheus/tsdb/encoding/encoding.go
deleted file mode 100644
index a732a6048e..0000000000
--- a/vendor/github.com/prometheus/tsdb/encoding/encoding.go
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright 2018 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.
-
-package encoding
-
-import (
-	"encoding/binary"
-	"hash"
-	"hash/crc32"
-	"unsafe"
-
-	"github.com/pkg/errors"
-)
-
-var (
-	ErrInvalidSize     = errors.New("invalid size")
-	ErrInvalidChecksum = errors.New("invalid checksum")
-)
-
-// Encbuf is a helper type to populate a byte slice with various types.
-type Encbuf struct {
-	B []byte
-	C [binary.MaxVarintLen64]byte
-}
-
-func (e *Encbuf) Reset()      { e.B = e.B[:0] }
-func (e *Encbuf) Get() []byte { return e.B }
-func (e *Encbuf) Len() int    { return len(e.B) }
-
-func (e *Encbuf) PutString(s string) { e.B = append(e.B, s...) }
-func (e *Encbuf) PutByte(c byte)     { e.B = append(e.B, c) }
-
-func (e *Encbuf) PutBE32int(x int)      { e.PutBE32(uint32(x)) }
-func (e *Encbuf) PutUvarint32(x uint32) { e.PutUvarint64(uint64(x)) }
-func (e *Encbuf) PutBE64int64(x int64)  { e.PutBE64(uint64(x)) }
-func (e *Encbuf) PutUvarint(x int)      { e.PutUvarint64(uint64(x)) }
-
-func (e *Encbuf) PutBE32(x uint32) {
-	binary.BigEndian.PutUint32(e.C[:], x)
-	e.B = append(e.B, e.C[:4]...)
-}
-
-func (e *Encbuf) PutBE64(x uint64) {
-	binary.BigEndian.PutUint64(e.C[:], x)
-	e.B = append(e.B, e.C[:8]...)
-}
-
-func (e *Encbuf) PutUvarint64(x uint64) {
-	n := binary.PutUvarint(e.C[:], x)
-	e.B = append(e.B, e.C[:n]...)
-}
-
-func (e *Encbuf) PutVarint64(x int64) {
-	n := binary.PutVarint(e.C[:], x)
-	e.B = append(e.B, e.C[:n]...)
-}
-
-// PutUvarintStr writes a string to the buffer prefixed by its varint length (in bytes!).
-func (e *Encbuf) PutUvarintStr(s string) {
-	b := *(*[]byte)(unsafe.Pointer(&s))
-	e.PutUvarint(len(b))
-	e.PutString(s)
-}
-
-// PutHash appends a hash over the buffers current contents to the buffer.
-func (e *Encbuf) PutHash(h hash.Hash) {
-	h.Reset()
-	_, err := h.Write(e.B)
-	if err != nil {
-		panic(err) // The CRC32 implementation does not error
-	}
-	e.B = h.Sum(e.B)
-}
-
-// Decbuf provides safe methods to extract data from a byte slice. It does all
-// necessary bounds checking and advancing of the byte slice.
-// Several datums can be extracted without checking for errors. However, before using
-// any datum, the err() method must be checked.
-type Decbuf struct {
-	B []byte
-	E error
-}
-
-// NewDecbufAt returns a new decoding buffer. It expects the first 4 bytes
-// after offset to hold the big endian encoded content length, followed by the contents and the expected
-// checksum.
-func NewDecbufAt(bs ByteSlice, off int, castagnoliTable *crc32.Table) Decbuf {
-	if bs.Len() < off+4 {
-		return Decbuf{E: ErrInvalidSize}
-	}
-	b := bs.Range(off, off+4)
-	l := int(binary.BigEndian.Uint32(b))
-
-	if bs.Len() < off+4+l+4 {
-		return Decbuf{E: ErrInvalidSize}
-	}
-
-	// Load bytes holding the contents plus a CRC32 checksum.
-	b = bs.Range(off+4, off+4+l+4)
-	dec := Decbuf{B: b[:len(b)-4]}
-
-	if exp := binary.BigEndian.Uint32(b[len(b)-4:]); dec.Crc32(castagnoliTable) != exp {
-		return Decbuf{E: ErrInvalidChecksum}
-	}
-	return dec
-}
-
-// NewDecbufUvarintAt returns a new decoding buffer. It expects the first bytes
-// after offset to hold the uvarint-encoded buffers length, followed by the contents and the expected
-// checksum.
-func NewDecbufUvarintAt(bs ByteSlice, off int, castagnoliTable *crc32.Table) Decbuf {
-	// We never have to access this method at the far end of the byte slice. Thus just checking
-	// against the MaxVarintLen32 is sufficient.
-	if bs.Len() < off+binary.MaxVarintLen32 {
-		return Decbuf{E: ErrInvalidSize}
-	}
-	b := bs.Range(off, off+binary.MaxVarintLen32)
-
-	l, n := binary.Uvarint(b)
-	if n <= 0 || n > binary.MaxVarintLen32 {
-		return Decbuf{E: errors.Errorf("invalid uvarint %d", n)}
-	}
-
-	if bs.Len() < off+n+int(l)+4 {
-		return Decbuf{E: ErrInvalidSize}
-	}
-
-	// Load bytes holding the contents plus a CRC32 checksum.
-	b = bs.Range(off+n, off+n+int(l)+4)
-	dec := Decbuf{B: b[:len(b)-4]}
-
-	if dec.Crc32(castagnoliTable) != binary.BigEndian.Uint32(b[len(b)-4:]) {
-		return Decbuf{E: ErrInvalidChecksum}
-	}
-	return dec
-}
-
-func (d *Decbuf) Uvarint() int     { return int(d.Uvarint64()) }
-func (d *Decbuf) Be32int() int     { return int(d.Be32()) }
-func (d *Decbuf) Be64int64() int64 { return int64(d.Be64()) }
-
-// Crc32 returns a CRC32 checksum over the remaining bytes.
-func (d *Decbuf) Crc32(castagnoliTable *crc32.Table) uint32 {
-	return crc32.Checksum(d.B, castagnoliTable)
-}
-
-func (d *Decbuf) UvarintStr() string {
-	l := d.Uvarint64()
-	if d.E != nil {
-		return ""
-	}
-	if len(d.B) < int(l) {
-		d.E = ErrInvalidSize
-		return ""
-	}
-	s := string(d.B[:l])
-	d.B = d.B[l:]
-	return s
-}
-
-func (d *Decbuf) Varint64() int64 {
-	if d.E != nil {
-		return 0
-	}
-	x, n := binary.Varint(d.B)
-	if n < 1 {
-		d.E = ErrInvalidSize
-		return 0
-	}
-	d.B = d.B[n:]
-	return x
-}
-
-func (d *Decbuf) Uvarint64() uint64 {
-	if d.E != nil {
-		return 0
-	}
-	x, n := binary.Uvarint(d.B)
-	if n < 1 {
-		d.E = ErrInvalidSize
-		return 0
-	}
-	d.B = d.B[n:]
-	return x
-}
-
-func (d *Decbuf) Be64() uint64 {
-	if d.E != nil {
-		return 0
-	}
-	if len(d.B) < 8 {
-		d.E = ErrInvalidSize
-		return 0
-	}
-	x := binary.BigEndian.Uint64(d.B)
-	d.B = d.B[8:]
-	return x
-}
-
-func (d *Decbuf) Be32() uint32 {
-	if d.E != nil {
-		return 0
-	}
-	if len(d.B) < 4 {
-		d.E = ErrInvalidSize
-		return 0
-	}
-	x := binary.BigEndian.Uint32(d.B)
-	d.B = d.B[4:]
-	return x
-}
-
-func (d *Decbuf) Byte() byte {
-	if d.E != nil {
-		return 0
-	}
-	if len(d.B) < 1 {
-		d.E = ErrInvalidSize
-		return 0
-	}
-	x := d.B[0]
-	d.B = d.B[1:]
-	return x
-}
-
-func (d *Decbuf) Err() error  { return d.E }
-func (d *Decbuf) Len() int    { return len(d.B) }
-func (d *Decbuf) Get() []byte { return d.B }
-
-// ByteSlice abstracts a byte slice.
-type ByteSlice interface {
-	Len() int
-	Range(start, end int) []byte
-}
diff --git a/vendor/github.com/prometheus/tsdb/errors/errors.go b/vendor/github.com/prometheus/tsdb/errors/errors.go
deleted file mode 100644
index 69d3662480..0000000000
--- a/vendor/github.com/prometheus/tsdb/errors/errors.go
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2016 The etcd 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.
-
-package errors
-
-import (
-	"bytes"
-	"fmt"
-)
-
-// The MultiError type implements the error interface, and contains the
-// Errors used to construct it.
-type MultiError []error
-
-// Returns a concatenated string of the contained errors
-func (es MultiError) Error() string {
-	var buf bytes.Buffer
-
-	if len(es) > 1 {
-		fmt.Fprintf(&buf, "%d errors: ", len(es))
-	}
-
-	for i, err := range es {
-		if i != 0 {
-			buf.WriteString("; ")
-		}
-		buf.WriteString(err.Error())
-	}
-
-	return buf.String()
-}
-
-// Add adds the error to the error list if it is not nil.
-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)
-	}
-}
-
-// Err returns the error list as an error or nil if it is empty.
-func (es MultiError) Err() error {
-	if len(es) == 0 {
-		return nil
-	}
-	return es
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/dir_unix.go b/vendor/github.com/prometheus/tsdb/fileutil/dir_unix.go
deleted file mode 100644
index 58a77dfc1a..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/dir_unix.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2016 The etcd 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.
-
-// +build !windows
-
-package fileutil
-
-import "os"
-
-// OpenDir opens a directory for syncing.
-func OpenDir(path string) (*os.File, error) { return os.Open(path) }
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/dir_windows.go b/vendor/github.com/prometheus/tsdb/fileutil/dir_windows.go
deleted file mode 100644
index c123395c00..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/dir_windows.go
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2016 The etcd 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.
-
-// +build windows
-
-package fileutil
-
-import (
-	"os"
-	"syscall"
-)
-
-// OpenDir opens a directory in windows with write access for syncing.
-func OpenDir(path string) (*os.File, error) {
-	fd, err := openDir(path)
-	if err != nil {
-		return nil, err
-	}
-	return os.NewFile(uintptr(fd), path), nil
-}
-
-func openDir(path string) (fd syscall.Handle, err error) {
-	if len(path) == 0 {
-		return syscall.InvalidHandle, syscall.ERROR_FILE_NOT_FOUND
-	}
-	pathp, err := syscall.UTF16PtrFromString(path)
-	if err != nil {
-		return syscall.InvalidHandle, err
-	}
-	access := uint32(syscall.GENERIC_READ | syscall.GENERIC_WRITE)
-	sharemode := uint32(syscall.FILE_SHARE_READ | syscall.FILE_SHARE_WRITE)
-	createmode := uint32(syscall.OPEN_EXISTING)
-	fl := uint32(syscall.FILE_FLAG_BACKUP_SEMANTICS)
-	return syscall.CreateFile(pathp, access, sharemode, nil, createmode, fl, 0)
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/fileutil.go b/vendor/github.com/prometheus/tsdb/fileutil/fileutil.go
deleted file mode 100644
index 4088f522ae..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/fileutil.go
+++ /dev/null
@@ -1,159 +0,0 @@
-// Copyright 2018 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.
-
-// Package fileutil provides utility methods used when dealing with the filesystem in tsdb.
-// It is largely copied from github.com/coreos/etcd/pkg/fileutil to avoid the
-// dependency chain it brings with it.
-// Please check github.com/coreos/etcd for licensing information.
-package fileutil
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-)
-
-// CopyDirs copies all directories, subdirectories and files recursively including the empty folders.
-// Source and destination must be full paths.
-func CopyDirs(src, dest string) error {
-	if err := os.MkdirAll(dest, 0777); err != nil {
-		return err
-	}
-	files, err := readDirs(src)
-	if err != nil {
-		return err
-	}
-
-	for _, f := range files {
-		dp := filepath.Join(dest, f)
-		sp := filepath.Join(src, f)
-
-		stat, err := os.Stat(sp)
-		if err != nil {
-			return err
-		}
-
-		// Empty directories are also created.
-		if stat.IsDir() {
-			if err := os.MkdirAll(dp, 0777); err != nil {
-				return err
-			}
-			continue
-		}
-
-		if err := copyFile(sp, dp); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func copyFile(src, dest string) error {
-	data, err := ioutil.ReadFile(src)
-	if err != nil {
-		return err
-	}
-
-	err = ioutil.WriteFile(dest, data, 0644)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// readDirs reads the source directory recursively and
-// returns relative paths to all files and empty directories.
-func readDirs(src string) ([]string, error) {
-	var files []string
-
-	err := filepath.Walk(src, func(path string, f os.FileInfo, err error) error {
-		relativePath := strings.TrimPrefix(path, src)
-		if len(relativePath) > 0 {
-			files = append(files, relativePath)
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return files, nil
-}
-
-// ReadDir returns the filenames in the given directory in sorted order.
-func ReadDir(dirpath string) ([]string, error) {
-	dir, err := os.Open(dirpath)
-	if err != nil {
-		return nil, err
-	}
-	defer dir.Close()
-	names, err := dir.Readdirnames(-1)
-	if err != nil {
-		return nil, err
-	}
-	sort.Strings(names)
-	return names, nil
-}
-
-// Rename safely renames a file.
-func Rename(from, to string) error {
-	if err := os.Rename(from, to); err != nil {
-		return err
-	}
-
-	// Directory was renamed; sync parent dir to persist rename.
-	pdir, err := OpenDir(filepath.Dir(to))
-	if err != nil {
-		return err
-	}
-
-	if err = pdir.Sync(); err != nil {
-		pdir.Close()
-		return err
-	}
-	return pdir.Close()
-}
-
-// Replace moves a file or directory to a new location and deletes any previous data.
-// It is not atomic.
-func Replace(from, to string) error {
-	// Remove destination only if it is a dir otherwise leave it to os.Rename
-	// as it replaces the destination file and is atomic.
-	{
-		f, err := os.Stat(to)
-		if !os.IsNotExist(err) {
-			if err == nil && f.IsDir() {
-				if err := os.RemoveAll(to); err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	if err := os.Rename(from, to); err != nil {
-		return err
-	}
-
-	// Directory was renamed; sync parent dir to persist rename.
-	pdir, err := OpenDir(filepath.Dir(to))
-	if err != nil {
-		return err
-	}
-
-	if err = pdir.Sync(); err != nil {
-		pdir.Close()
-		return err
-	}
-	return pdir.Close()
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/flock.go b/vendor/github.com/prometheus/tsdb/fileutil/flock.go
deleted file mode 100644
index d5eaa7ca2a..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/flock.go
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2016 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.
-
-package fileutil
-
-import (
-	"os"
-	"path/filepath"
-)
-
-// Releaser provides the Release method to release a file lock.
-type Releaser interface {
-	Release() error
-}
-
-// Flock locks the file with the provided name. If the file does not exist, it is
-// created. The returned Releaser is used to release the lock. existed is true
-// if the file to lock already existed. A non-nil error is returned if the
-// locking has failed. Neither this function nor the returned Releaser is
-// goroutine-safe.
-func Flock(fileName string) (r Releaser, existed bool, err error) {
-	if err = os.MkdirAll(filepath.Dir(fileName), 0755); err != nil {
-		return nil, false, err
-	}
-
-	_, err = os.Stat(fileName)
-	existed = err == nil
-
-	r, err = newLock(fileName)
-	return r, existed, err
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/flock_plan9.go b/vendor/github.com/prometheus/tsdb/fileutil/flock_plan9.go
deleted file mode 100644
index 8a3d44c5e1..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/flock_plan9.go
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2016 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.
-
-package fileutil
-
-import "os"
-
-type plan9Lock struct {
-	f *os.File
-}
-
-func (l *plan9Lock) Release() error {
-	return l.f.Close()
-}
-
-func newLock(fileName string) (Releaser, error) {
-	f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, os.ModeExclusive|0644)
-	if err != nil {
-		return nil, err
-	}
-	return &plan9Lock{f}, nil
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/flock_solaris.go b/vendor/github.com/prometheus/tsdb/fileutil/flock_solaris.go
deleted file mode 100644
index 7f527ae6c4..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/flock_solaris.go
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2016 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.
-
-// +build solaris
-
-package fileutil
-
-import (
-	"os"
-	"syscall"
-)
-
-type unixLock struct {
-	f *os.File
-}
-
-func (l *unixLock) Release() error {
-	if err := l.set(false); err != nil {
-		return err
-	}
-	return l.f.Close()
-}
-
-func (l *unixLock) set(lock bool) error {
-	flock := syscall.Flock_t{
-		Type:   syscall.F_UNLCK,
-		Start:  0,
-		Len:    0,
-		Whence: 1,
-	}
-	if lock {
-		flock.Type = syscall.F_WRLCK
-	}
-	return syscall.FcntlFlock(l.f.Fd(), syscall.F_SETLK, &flock)
-}
-
-func newLock(fileName string) (Releaser, error) {
-	f, err := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE, 0644)
-	if err != nil {
-		return nil, err
-	}
-	l := &unixLock{f}
-	err = l.set(true)
-	if err != nil {
-		f.Close()
-		return nil, err
-	}
-	return l, nil
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/flock_unix.go b/vendor/github.com/prometheus/tsdb/fileutil/flock_unix.go
deleted file mode 100644
index f493fbd831..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/flock_unix.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2016 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.
-
-// +build darwin dragonfly freebsd linux netbsd openbsd
-
-package fileutil
-
-import (
-	"os"
-	"syscall"
-)
-
-type unixLock struct {
-	f *os.File
-}
-
-func (l *unixLock) Release() error {
-	if err := l.set(false); err != nil {
-		return err
-	}
-	return l.f.Close()
-}
-
-func (l *unixLock) set(lock bool) error {
-	how := syscall.LOCK_UN
-	if lock {
-		how = syscall.LOCK_EX
-	}
-	return syscall.Flock(int(l.f.Fd()), how|syscall.LOCK_NB)
-}
-
-func newLock(fileName string) (Releaser, error) {
-	f, err := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE, 0644)
-	if err != nil {
-		return nil, err
-	}
-	l := &unixLock{f}
-	err = l.set(true)
-	if err != nil {
-		f.Close()
-		return nil, err
-	}
-	return l, nil
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/flock_windows.go b/vendor/github.com/prometheus/tsdb/fileutil/flock_windows.go
deleted file mode 100644
index 1c17ff4ea3..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/flock_windows.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2016 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.
-
-package fileutil
-
-import "syscall"
-
-type windowsLock struct {
-	fd syscall.Handle
-}
-
-func (fl *windowsLock) Release() error {
-	return syscall.Close(fl.fd)
-}
-
-func newLock(fileName string) (Releaser, error) {
-	pathp, err := syscall.UTF16PtrFromString(fileName)
-	if err != nil {
-		return nil, err
-	}
-	fd, err := syscall.CreateFile(pathp, syscall.GENERIC_READ|syscall.GENERIC_WRITE, 0, nil, syscall.CREATE_ALWAYS, syscall.FILE_ATTRIBUTE_NORMAL, 0)
-	if err != nil {
-		return nil, err
-	}
-	return &windowsLock{fd}, nil
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/mmap.go b/vendor/github.com/prometheus/tsdb/fileutil/mmap.go
deleted file mode 100644
index 26fc80c585..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/mmap.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2018 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.
-
-package fileutil
-
-import (
-	"os"
-
-	"github.com/pkg/errors"
-)
-
-type MmapFile struct {
-	f *os.File
-	b []byte
-}
-
-func OpenMmapFile(path string) (*MmapFile, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, errors.Wrap(err, "try lock file")
-	}
-	info, err := f.Stat()
-	if err != nil {
-		return nil, errors.Wrap(err, "stat")
-	}
-
-	b, err := mmap(f, int(info.Size()))
-	if err != nil {
-		return nil, errors.Wrap(err, "mmap")
-	}
-
-	return &MmapFile{f: f, b: b}, nil
-}
-
-func (f *MmapFile) Close() error {
-	err0 := munmap(f.b)
-	err1 := f.f.Close()
-
-	if err0 != nil {
-		return err0
-	}
-	return err1
-}
-
-func (f *MmapFile) File() *os.File {
-	return f.f
-}
-
-func (f *MmapFile) Bytes() []byte {
-	return f.b
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/mmap_386.go b/vendor/github.com/prometheus/tsdb/fileutil/mmap_386.go
deleted file mode 100644
index 66b9d36803..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/mmap_386.go
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright 2018 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.
-
-// +build windows
-
-package fileutil
-
-const maxMapSize = 0x7FFFFFFF // 2GB
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/mmap_amd64.go b/vendor/github.com/prometheus/tsdb/fileutil/mmap_amd64.go
deleted file mode 100644
index 4b523bc67c..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/mmap_amd64.go
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright 2018 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.
-
-// +build windows
-
-package fileutil
-
-const maxMapSize = 0xFFFFFFFFFFFF // 256TB
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/mmap_unix.go b/vendor/github.com/prometheus/tsdb/fileutil/mmap_unix.go
deleted file mode 100644
index 043f4d408c..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/mmap_unix.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2017 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.
-
-// +build !windows,!plan9
-
-package fileutil
-
-import (
-	"os"
-
-	"golang.org/x/sys/unix"
-)
-
-func mmap(f *os.File, length int) ([]byte, error) {
-	return unix.Mmap(int(f.Fd()), 0, length, unix.PROT_READ, unix.MAP_SHARED)
-}
-
-func munmap(b []byte) (err error) {
-	return unix.Munmap(b)
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/mmap_windows.go b/vendor/github.com/prometheus/tsdb/fileutil/mmap_windows.go
deleted file mode 100644
index b942264123..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/mmap_windows.go
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2017 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.
-
-package fileutil
-
-import (
-	"os"
-	"syscall"
-	"unsafe"
-)
-
-func mmap(f *os.File, size int) ([]byte, error) {
-	low, high := uint32(size), uint32(size>>32)
-	h, errno := syscall.CreateFileMapping(syscall.Handle(f.Fd()), nil, syscall.PAGE_READONLY, high, low, nil)
-	if h == 0 {
-		return nil, os.NewSyscallError("CreateFileMapping", errno)
-	}
-
-	addr, errno := syscall.MapViewOfFile(h, syscall.FILE_MAP_READ, 0, 0, uintptr(size))
-	if addr == 0 {
-		return nil, os.NewSyscallError("MapViewOfFile", errno)
-	}
-
-	if err := syscall.CloseHandle(syscall.Handle(h)); err != nil {
-		return nil, os.NewSyscallError("CloseHandle", err)
-	}
-
-	return (*[maxMapSize]byte)(unsafe.Pointer(addr))[:size], nil
-}
-
-func munmap(b []byte) error {
-	if err := syscall.UnmapViewOfFile((uintptr)(unsafe.Pointer(&b[0]))); err != nil {
-		return os.NewSyscallError("UnmapViewOfFile", err)
-	}
-	return nil
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/preallocate.go b/vendor/github.com/prometheus/tsdb/fileutil/preallocate.go
deleted file mode 100644
index c747b7cf81..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/preallocate.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2015 The etcd 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.
-
-package fileutil
-
-import (
-	"io"
-	"os"
-)
-
-// Preallocate tries to allocate the space for given
-// file. This operation is only supported on linux by a
-// few filesystems (btrfs, ext4, etc.).
-// If the operation is unsupported, no error will be returned.
-// Otherwise, the error encountered will be returned.
-func Preallocate(f *os.File, sizeInBytes int64, extendFile bool) error {
-	if sizeInBytes == 0 {
-		// fallocate will return EINVAL if length is 0; skip
-		return nil
-	}
-	if extendFile {
-		return preallocExtend(f, sizeInBytes)
-	}
-	return preallocFixed(f, sizeInBytes)
-}
-
-func preallocExtendTrunc(f *os.File, sizeInBytes int64) error {
-	curOff, err := f.Seek(0, io.SeekCurrent)
-	if err != nil {
-		return err
-	}
-	size, err := f.Seek(sizeInBytes, io.SeekEnd)
-	if err != nil {
-		return err
-	}
-	if _, err = f.Seek(curOff, io.SeekStart); err != nil {
-		return err
-	}
-	if sizeInBytes > size {
-		return nil
-	}
-	return f.Truncate(sizeInBytes)
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/preallocate_darwin.go b/vendor/github.com/prometheus/tsdb/fileutil/preallocate_darwin.go
deleted file mode 100644
index c9fa1a6c22..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/preallocate_darwin.go
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2015 The etcd 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.
-
-package fileutil
-
-import (
-	"os"
-	"syscall"
-	"unsafe"
-)
-
-func preallocExtend(f *os.File, sizeInBytes int64) error {
-	if err := preallocFixed(f, sizeInBytes); err != nil {
-		return err
-	}
-	return preallocExtendTrunc(f, sizeInBytes)
-}
-
-func preallocFixed(f *os.File, sizeInBytes int64) error {
-	fstore := &syscall.Fstore_t{
-		Flags:   syscall.F_ALLOCATEALL,
-		Posmode: syscall.F_PEOFPOSMODE,
-		Length:  sizeInBytes}
-	p := unsafe.Pointer(fstore)
-	_, _, errno := syscall.Syscall(syscall.SYS_FCNTL, f.Fd(), uintptr(syscall.F_PREALLOCATE), uintptr(p))
-	if errno == 0 || errno == syscall.ENOTSUP {
-		return nil
-	}
-	return errno
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/preallocate_linux.go b/vendor/github.com/prometheus/tsdb/fileutil/preallocate_linux.go
deleted file mode 100644
index ada0462213..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/preallocate_linux.go
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2015 The etcd 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.
-
-package fileutil
-
-import (
-	"os"
-	"syscall"
-)
-
-func preallocExtend(f *os.File, sizeInBytes int64) error {
-	// use mode = 0 to change size
-	err := syscall.Fallocate(int(f.Fd()), 0, 0, sizeInBytes)
-	if err != nil {
-		errno, ok := err.(syscall.Errno)
-		// not supported; fallback
-		// fallocate EINTRs frequently in some environments; fallback
-		if ok && (errno == syscall.ENOTSUP || errno == syscall.EINTR) {
-			return preallocExtendTrunc(f, sizeInBytes)
-		}
-	}
-	return err
-}
-
-func preallocFixed(f *os.File, sizeInBytes int64) error {
-	// use mode = 1 to keep size; see FALLOC_FL_KEEP_SIZE
-	err := syscall.Fallocate(int(f.Fd()), 1, 0, sizeInBytes)
-	if err != nil {
-		errno, ok := err.(syscall.Errno)
-		// treat not supported as nil error
-		if ok && errno == syscall.ENOTSUP {
-			return nil
-		}
-	}
-	return err
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/preallocate_other.go b/vendor/github.com/prometheus/tsdb/fileutil/preallocate_other.go
deleted file mode 100644
index 162fbc5f78..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/preallocate_other.go
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2015 The etcd 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.
-
-// +build !linux,!darwin
-
-package fileutil
-
-import "os"
-
-func preallocExtend(f *os.File, sizeInBytes int64) error {
-	return preallocExtendTrunc(f, sizeInBytes)
-}
-
-func preallocFixed(f *os.File, sizeInBytes int64) error { return nil }
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/sync.go b/vendor/github.com/prometheus/tsdb/fileutil/sync.go
deleted file mode 100644
index 2e64a40880..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/sync.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2016 The etcd 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.
-
-// +build !linux,!darwin
-
-package fileutil
-
-import "os"
-
-// Fdatasync is a wrapper around file.Sync(). Special handling is needed on linux platform.
-func Fdatasync(f *os.File) error {
-	return f.Sync()
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/sync_darwin.go b/vendor/github.com/prometheus/tsdb/fileutil/sync_darwin.go
deleted file mode 100644
index 2af1b0f411..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/sync_darwin.go
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2016 The etcd 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.
-
-// +build darwin
-
-package fileutil
-
-import (
-	"os"
-)
-
-// Fdatasync on darwin platform invokes fcntl(F_FULLFSYNC) for actual persistence
-// on physical drive media.
-func Fdatasync(f *os.File) error {
-	return f.Sync()
-}
diff --git a/vendor/github.com/prometheus/tsdb/fileutil/sync_linux.go b/vendor/github.com/prometheus/tsdb/fileutil/sync_linux.go
deleted file mode 100644
index 8b4fc8268e..0000000000
--- a/vendor/github.com/prometheus/tsdb/fileutil/sync_linux.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2016 The etcd 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.
-
-// +build linux
-
-package fileutil
-
-import (
-	"os"
-	"syscall"
-)
-
-// Fdatasync is similar to fsync(), but does not flush modified metadata
-// unless that metadata is needed in order to allow a subsequent data retrieval
-// to be correctly handled.
-func Fdatasync(f *os.File) error {
-	return syscall.Fdatasync(int(f.Fd()))
-}
diff --git a/vendor/github.com/prometheus/tsdb/go.mod b/vendor/github.com/prometheus/tsdb/go.mod
deleted file mode 100644
index ccdd437247..0000000000
--- a/vendor/github.com/prometheus/tsdb/go.mod
+++ /dev/null
@@ -1,14 +0,0 @@
-module github.com/prometheus/tsdb
-
-require (
-	github.com/cespare/xxhash v1.1.0
-	github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954
-	github.com/go-kit/kit v0.8.0
-	github.com/golang/snappy v0.0.1
-	github.com/oklog/ulid v1.3.1
-	github.com/pkg/errors v0.8.0
-	github.com/prometheus/client_golang v1.0.0
-	golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4
-	golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5
-	gopkg.in/alecthomas/kingpin.v2 v2.2.6
-)
diff --git a/vendor/github.com/prometheus/tsdb/go.sum b/vendor/github.com/prometheus/tsdb/go.sum
deleted file mode 100644
index 365fa5ecf4..0000000000
--- a/vendor/github.com/prometheus/tsdb/go.sum
+++ /dev/null
@@ -1,83 +0,0 @@
-github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE=
-github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc h1:cAKDfWh5VpdgMhJosfJnn5/FoN2SRZ4p7fJNX58YPaU=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf h1:qet1QNfXsQxTZqLG4oE62mJzwPIB8+Tee4RNCL9ulrY=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973 h1:xJ4a3vCFaGF/jqvzLMYoU8P317H5OQ+Via4RmuPwCS0=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
-github.com/beorn7/perks v1.0.0 h1:HWo1m869IqiPhD389kmkxeTalrjNbbJTC8LXupb+sl0=
-github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
-github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
-github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954 h1:RMLoZVzv4GliuWafOuPuQDKSm1SJph7uCRnnS61JAn4=
-github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/go-kit/kit v0.8.0 h1:Wz+5lgoB0kkuqLEc6NVmwRknTKP6dTGbSqvhZtBI/j0=
-github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-logfmt/logfmt v0.3.0 h1:8HUsc87TaSWLKwrnumgC8/YconD2fJQsRJAsWaPg2ic=
-github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
-github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
-github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/gogo/protobuf v1.1.1 h1:72R+M5VuhED/KujmZVcIquuo8mBgX4oVda//DQb3PXo=
-github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
-github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 h1:T+h1c/A9Gawja4Y9mFVWj2vyii2bbUNDw3kt9VxK2EY=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
-github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
-github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/oklog/ulid v1.3.1 h1:EGfNDEx6MqHz8B3uNV6QAib1UR2Lm97sHi3ocA6ESJ4=
-github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
-github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v0.9.1 h1:K47Rk0v/fkEfwfQet2KWhscE0cJzjgCCDBG2KHZoVno=
-github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
-github.com/prometheus/client_golang v1.0.0 h1:vrDKnkGzuGvhNAL56c7DBz29ZL+KxnoR0x7enabFceM=
-github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910 h1:idejC8f05m9MGOsuEi1ATq9shN03HrxNkD/luQvxCv8=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
-github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90 h1:S/YWwWx/RA8rT8tKFRuGUZhuA90OyIBpPCXkcbwU8DE=
-github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/common v0.4.1 h1:K0MGApIoQvMw27RTdJkPbr3JZ7DNbtxQNyi5STVM6Kw=
-github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d h1:GoAlyOgbOEIFdaDqxJVlbOQ1DtGmZWs/Qau0hIlk+WQ=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/procfs v0.0.2 h1:6LJUbpNm42llc4HRCuvApCSWB/WfhuNo9K98Q9sNGfs=
-github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
-github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 h1:qLC7fQah7D6K1B0ujays3HV9gkFtllcxhzImRR7ArPQ=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4 h1:YUO/7uOKsKeq9UokNS62b8FYywz3ker1l1vDZRCRefw=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5 h1:mzjBh+S5frKOsOBobWIMAbXavqjmgO17k/2puhcFR94=
-golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-gopkg.in/alecthomas/kingpin.v2 v2.2.6 h1:jMFz6MfLP0/4fUyZle81rXUoxOBFi19VUFKVDOQfozc=
-gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/vendor/github.com/prometheus/tsdb/goversion/goversion.go b/vendor/github.com/prometheus/tsdb/goversion/goversion.go
deleted file mode 100644
index 8b194d4a2b..0000000000
--- a/vendor/github.com/prometheus/tsdb/goversion/goversion.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2017 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.
-
-// +build go1.12
-
-// Package goversion enforces the go version suported by the tsdb module.
-package goversion
-
-const _SoftwareRequiresGOVERSION1_12 = uint8(0)
diff --git a/vendor/github.com/prometheus/tsdb/goversion/init.go b/vendor/github.com/prometheus/tsdb/goversion/init.go
deleted file mode 100644
index dd15e1f7af..0000000000
--- a/vendor/github.com/prometheus/tsdb/goversion/init.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2017 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.
-
-package goversion
-
-// This will fail to compile if the Go runtime version isn't >= 1.12.
-var _ = _SoftwareRequiresGOVERSION1_12
diff --git a/vendor/github.com/prometheus/tsdb/head.go b/vendor/github.com/prometheus/tsdb/head.go
deleted file mode 100644
index 0adb8847a9..0000000000
--- a/vendor/github.com/prometheus/tsdb/head.go
+++ /dev/null
@@ -1,1873 +0,0 @@
-// Copyright 2017 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.
-
-package tsdb
-
-import (
-	"fmt"
-	"math"
-	"runtime"
-	"sort"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
-	"github.com/oklog/ulid"
-	"github.com/pkg/errors"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
-	"github.com/prometheus/tsdb/encoding"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/wal"
-)
-
-var (
-	// ErrNotFound is returned if a looked up resource was not found.
-	ErrNotFound = errors.Errorf("not found")
-
-	// ErrOutOfOrderSample is returned if an appended sample has a
-	// timestamp smaller than the most recent sample.
-	ErrOutOfOrderSample = errors.New("out of order sample")
-
-	// ErrAmendSample is returned if an appended sample has the same timestamp
-	// as the most recent sample but a different value.
-	ErrAmendSample = errors.New("amending sample")
-
-	// ErrOutOfBounds is returned if an appended sample is out of the
-	// writable time range.
-	ErrOutOfBounds = errors.New("out of bounds")
-
-	// emptyTombstoneReader is a no-op Tombstone Reader.
-	// This is used by head to satisfy the Tombstones() function call.
-	emptyTombstoneReader = newMemTombstones()
-)
-
-// Head handles reads and writes of time series data within a time window.
-type Head struct {
-	chunkRange int64
-	metrics    *headMetrics
-	wal        *wal.WAL
-	logger     log.Logger
-	appendPool sync.Pool
-	bytesPool  sync.Pool
-	numSeries  uint64
-
-	minTime, maxTime int64 // Current min and max of the samples included in the head.
-	minValidTime     int64 // Mint allowed to be added to the head. It shouldn't be lower than the maxt of the last persisted block.
-	lastSeriesID     uint64
-
-	// All series addressable by their ID or hash.
-	series *stripeSeries
-
-	symMtx  sync.RWMutex
-	symbols map[string]struct{}
-	values  map[string]stringset // label names to possible values
-
-	deletedMtx sync.Mutex
-	deleted    map[uint64]int // Deleted series, and what WAL segment they must be kept until.
-
-	postings *index.MemPostings // postings lists for terms
-}
-
-type headMetrics struct {
-	activeAppenders         prometheus.Gauge
-	series                  prometheus.GaugeFunc
-	seriesCreated           prometheus.Counter
-	seriesRemoved           prometheus.Counter
-	seriesNotFound          prometheus.Counter
-	chunks                  prometheus.Gauge
-	chunksCreated           prometheus.Counter
-	chunksRemoved           prometheus.Counter
-	gcDuration              prometheus.Summary
-	minTime                 prometheus.GaugeFunc
-	maxTime                 prometheus.GaugeFunc
-	samplesAppended         prometheus.Counter
-	walTruncateDuration     prometheus.Summary
-	walCorruptionsTotal     prometheus.Counter
-	headTruncateFail        prometheus.Counter
-	headTruncateTotal       prometheus.Counter
-	checkpointDeleteFail    prometheus.Counter
-	checkpointDeleteTotal   prometheus.Counter
-	checkpointCreationFail  prometheus.Counter
-	checkpointCreationTotal prometheus.Counter
-}
-
-func newHeadMetrics(h *Head, r prometheus.Registerer) *headMetrics {
-	m := &headMetrics{}
-
-	m.activeAppenders = prometheus.NewGauge(prometheus.GaugeOpts{
-		Name: "prometheus_tsdb_head_active_appenders",
-		Help: "Number of currently active appender transactions",
-	})
-	m.series = prometheus.NewGaugeFunc(prometheus.GaugeOpts{
-		Name: "prometheus_tsdb_head_series",
-		Help: "Total number of series in the head block.",
-	}, func() float64 {
-		return float64(h.NumSeries())
-	})
-	m.seriesCreated = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_head_series_created_total",
-		Help: "Total number of series created in the head",
-	})
-	m.seriesRemoved = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_head_series_removed_total",
-		Help: "Total number of series removed in the head",
-	})
-	m.seriesNotFound = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_head_series_not_found_total",
-		Help: "Total number of requests for series that were not found.",
-	})
-	m.chunks = prometheus.NewGauge(prometheus.GaugeOpts{
-		Name: "prometheus_tsdb_head_chunks",
-		Help: "Total number of chunks in the head block.",
-	})
-	m.chunksCreated = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_head_chunks_created_total",
-		Help: "Total number of chunks created in the head",
-	})
-	m.chunksRemoved = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_head_chunks_removed_total",
-		Help: "Total number of chunks removed in the head",
-	})
-	m.gcDuration = prometheus.NewSummary(prometheus.SummaryOpts{
-		Name:       "prometheus_tsdb_head_gc_duration_seconds",
-		Help:       "Runtime of garbage collection in the head block.",
-		Objectives: map[float64]float64{},
-	})
-	m.maxTime = prometheus.NewGaugeFunc(prometheus.GaugeOpts{
-		Name: "prometheus_tsdb_head_max_time",
-		Help: "Maximum timestamp of the head block. The unit is decided by the library consumer.",
-	}, func() float64 {
-		return float64(h.MaxTime())
-	})
-	m.minTime = prometheus.NewGaugeFunc(prometheus.GaugeOpts{
-		Name: "prometheus_tsdb_head_min_time",
-		Help: "Minimum time bound of the head block. The unit is decided by the library consumer.",
-	}, func() float64 {
-		return float64(h.MinTime())
-	})
-	m.walTruncateDuration = prometheus.NewSummary(prometheus.SummaryOpts{
-		Name:       "prometheus_tsdb_wal_truncate_duration_seconds",
-		Help:       "Duration of WAL truncation.",
-		Objectives: map[float64]float64{},
-	})
-	m.walCorruptionsTotal = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_wal_corruptions_total",
-		Help: "Total number of WAL corruptions.",
-	})
-	m.samplesAppended = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_head_samples_appended_total",
-		Help: "Total number of appended samples.",
-	})
-	m.headTruncateFail = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_head_truncations_failed_total",
-		Help: "Total number of head truncations that failed.",
-	})
-	m.headTruncateTotal = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_head_truncations_total",
-		Help: "Total number of head truncations attempted.",
-	})
-	m.checkpointDeleteFail = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_checkpoint_deletions_failed_total",
-		Help: "Total number of checkpoint deletions that failed.",
-	})
-	m.checkpointDeleteTotal = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_checkpoint_deletions_total",
-		Help: "Total number of checkpoint deletions attempted.",
-	})
-	m.checkpointCreationFail = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_checkpoint_creations_failed_total",
-		Help: "Total number of checkpoint creations that failed.",
-	})
-	m.checkpointCreationTotal = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_checkpoint_creations_total",
-		Help: "Total number of checkpoint creations attempted.",
-	})
-
-	if r != nil {
-		r.MustRegister(
-			m.activeAppenders,
-			m.chunks,
-			m.chunksCreated,
-			m.chunksRemoved,
-			m.series,
-			m.seriesCreated,
-			m.seriesRemoved,
-			m.seriesNotFound,
-			m.minTime,
-			m.maxTime,
-			m.gcDuration,
-			m.walTruncateDuration,
-			m.walCorruptionsTotal,
-			m.samplesAppended,
-			m.headTruncateFail,
-			m.headTruncateTotal,
-			m.checkpointDeleteFail,
-			m.checkpointDeleteTotal,
-			m.checkpointCreationFail,
-			m.checkpointCreationTotal,
-		)
-	}
-	return m
-}
-
-// NewHead opens the head block in dir.
-func NewHead(r prometheus.Registerer, l log.Logger, wal *wal.WAL, chunkRange int64) (*Head, error) {
-	if l == nil {
-		l = log.NewNopLogger()
-	}
-	if chunkRange < 1 {
-		return nil, errors.Errorf("invalid chunk range %d", chunkRange)
-	}
-	h := &Head{
-		wal:        wal,
-		logger:     l,
-		chunkRange: chunkRange,
-		minTime:    math.MaxInt64,
-		maxTime:    math.MinInt64,
-		series:     newStripeSeries(),
-		values:     map[string]stringset{},
-		symbols:    map[string]struct{}{},
-		postings:   index.NewUnorderedMemPostings(),
-		deleted:    map[uint64]int{},
-	}
-	h.metrics = newHeadMetrics(h, r)
-
-	return h, nil
-}
-
-// processWALSamples adds a partition of samples it receives to the head and passes
-// them on to other workers.
-// Samples before the mint timestamp are discarded.
-func (h *Head) processWALSamples(
-	minValidTime int64,
-	input <-chan []RefSample, output chan<- []RefSample,
-) (unknownRefs uint64) {
-	defer close(output)
-
-	// Mitigate lock contention in getByID.
-	refSeries := map[uint64]*memSeries{}
-
-	mint, maxt := int64(math.MaxInt64), int64(math.MinInt64)
-
-	for samples := range input {
-		for _, s := range samples {
-			if s.T < minValidTime {
-				continue
-			}
-			ms := refSeries[s.Ref]
-			if ms == nil {
-				ms = h.series.getByID(s.Ref)
-				if ms == nil {
-					unknownRefs++
-					continue
-				}
-				refSeries[s.Ref] = ms
-			}
-			_, chunkCreated := ms.append(s.T, s.V)
-			if chunkCreated {
-				h.metrics.chunksCreated.Inc()
-				h.metrics.chunks.Inc()
-			}
-			if s.T > maxt {
-				maxt = s.T
-			}
-			if s.T < mint {
-				mint = s.T
-			}
-		}
-		output <- samples
-	}
-	h.updateMinMaxTime(mint, maxt)
-
-	return unknownRefs
-}
-
-func (h *Head) updateMinMaxTime(mint, maxt int64) {
-	for {
-		lt := h.MinTime()
-		if mint >= lt {
-			break
-		}
-		if atomic.CompareAndSwapInt64(&h.minTime, lt, mint) {
-			break
-		}
-	}
-	for {
-		ht := h.MaxTime()
-		if maxt <= ht {
-			break
-		}
-		if atomic.CompareAndSwapInt64(&h.maxTime, ht, maxt) {
-			break
-		}
-	}
-}
-
-func (h *Head) loadWAL(r *wal.Reader, multiRef map[uint64]uint64) (err error) {
-	// Track number of samples that referenced a series we don't know about
-	// for error reporting.
-	var unknownRefs uint64
-
-	// Start workers that each process samples for a partition of the series ID space.
-	// They are connected through a ring of channels which ensures that all sample batches
-	// read from the WAL are processed in order.
-	var (
-		wg           sync.WaitGroup
-		multiRefLock sync.Mutex
-		n            = runtime.GOMAXPROCS(0)
-		inputs       = make([]chan []RefSample, n)
-		outputs      = make([]chan []RefSample, n)
-	)
-	wg.Add(n)
-
-	defer func() {
-		// For CorruptionErr ensure to terminate all workers before exiting.
-		if _, ok := err.(*wal.CorruptionErr); ok {
-			for i := 0; i < n; i++ {
-				close(inputs[i])
-				for range outputs[i] {
-				}
-			}
-			wg.Wait()
-		}
-	}()
-
-	for i := 0; i < n; i++ {
-		outputs[i] = make(chan []RefSample, 300)
-		inputs[i] = make(chan []RefSample, 300)
-
-		go func(input <-chan []RefSample, output chan<- []RefSample) {
-			unknown := h.processWALSamples(h.minValidTime, input, output)
-			atomic.AddUint64(&unknownRefs, unknown)
-			wg.Done()
-		}(inputs[i], outputs[i])
-	}
-
-	var (
-		dec       RecordDecoder
-		series    []RefSeries
-		samples   []RefSample
-		tstones   []Stone
-		allStones = newMemTombstones()
-	)
-	defer func() {
-		if err := allStones.Close(); err != nil {
-			level.Warn(h.logger).Log("msg", "closing  memTombstones during wal read", "err", err)
-		}
-	}()
-	for r.Next() {
-		series, samples, tstones = series[:0], samples[:0], tstones[:0]
-		rec := r.Record()
-
-		switch dec.Type(rec) {
-		case RecordSeries:
-			series, err = dec.Series(rec, series)
-			if err != nil {
-				return &wal.CorruptionErr{
-					Err:     errors.Wrap(err, "decode series"),
-					Segment: r.Segment(),
-					Offset:  r.Offset(),
-				}
-			}
-			for _, s := range series {
-				series, created := h.getOrCreateWithID(s.Ref, s.Labels.Hash(), s.Labels)
-
-				if !created {
-					// There's already a different ref for this series.
-					multiRefLock.Lock()
-					multiRef[s.Ref] = series.ref
-					multiRefLock.Unlock()
-				}
-
-				if h.lastSeriesID < s.Ref {
-					h.lastSeriesID = s.Ref
-				}
-			}
-		case RecordSamples:
-			samples, err = dec.Samples(rec, samples)
-			s := samples
-			if err != nil {
-				return &wal.CorruptionErr{
-					Err:     errors.Wrap(err, "decode samples"),
-					Segment: r.Segment(),
-					Offset:  r.Offset(),
-				}
-			}
-			// We split up the samples into chunks of 5000 samples or less.
-			// With O(300 * #cores) in-flight sample batches, large scrapes could otherwise
-			// cause thousands of very large in flight buffers occupying large amounts
-			// of unused memory.
-			for len(samples) > 0 {
-				m := 5000
-				if len(samples) < m {
-					m = len(samples)
-				}
-				shards := make([][]RefSample, n)
-				for i := 0; i < n; i++ {
-					var buf []RefSample
-					select {
-					case buf = <-outputs[i]:
-					default:
-					}
-					shards[i] = buf[:0]
-				}
-				for _, sam := range samples[:m] {
-					if r, ok := multiRef[sam.Ref]; ok {
-						sam.Ref = r
-					}
-					mod := sam.Ref % uint64(n)
-					shards[mod] = append(shards[mod], sam)
-				}
-				for i := 0; i < n; i++ {
-					inputs[i] <- shards[i]
-				}
-				samples = samples[m:]
-			}
-			samples = s // Keep whole slice for reuse.
-		case RecordTombstones:
-			tstones, err = dec.Tombstones(rec, tstones)
-			if err != nil {
-				return &wal.CorruptionErr{
-					Err:     errors.Wrap(err, "decode tombstones"),
-					Segment: r.Segment(),
-					Offset:  r.Offset(),
-				}
-			}
-			for _, s := range tstones {
-				for _, itv := range s.intervals {
-					if itv.Maxt < h.minValidTime {
-						continue
-					}
-					if m := h.series.getByID(s.ref); m == nil {
-						unknownRefs++
-						continue
-					}
-					allStones.addInterval(s.ref, itv)
-				}
-			}
-		default:
-			return &wal.CorruptionErr{
-				Err:     errors.Errorf("invalid record type %v", dec.Type(rec)),
-				Segment: r.Segment(),
-				Offset:  r.Offset(),
-			}
-		}
-	}
-
-	// Signal termination to each worker and wait for it to close its output channel.
-	for i := 0; i < n; i++ {
-		close(inputs[i])
-		for range outputs[i] {
-		}
-	}
-	wg.Wait()
-
-	if r.Err() != nil {
-		return errors.Wrap(r.Err(), "read records")
-	}
-
-	if err := allStones.Iter(func(ref uint64, dranges Intervals) error {
-		return h.chunkRewrite(ref, dranges)
-	}); err != nil {
-		return errors.Wrap(r.Err(), "deleting samples from tombstones")
-	}
-
-	if unknownRefs > 0 {
-		level.Warn(h.logger).Log("msg", "unknown series references", "count", unknownRefs)
-	}
-	return nil
-}
-
-// Init loads data from the write ahead log and prepares the head for writes.
-// It should be called before using an appender so that
-// limits the ingested samples to the head min valid time.
-func (h *Head) Init(minValidTime int64) error {
-	h.minValidTime = minValidTime
-	defer h.postings.EnsureOrder()
-	defer h.gc() // After loading the wal remove the obsolete data from the head.
-
-	if h.wal == nil {
-		return nil
-	}
-
-	level.Info(h.logger).Log("msg", "replaying WAL, this may take awhile")
-	// Backfill the checkpoint first if it exists.
-	dir, startFrom, err := LastCheckpoint(h.wal.Dir())
-	if err != nil && err != ErrNotFound {
-		return errors.Wrap(err, "find last checkpoint")
-	}
-	multiRef := map[uint64]uint64{}
-	if err == nil {
-		sr, err := wal.NewSegmentsReader(dir)
-		if err != nil {
-			return errors.Wrap(err, "open checkpoint")
-		}
-		defer func() {
-			if err := sr.Close(); err != nil {
-				level.Warn(h.logger).Log("msg", "error while closing the wal segments reader", "err", err)
-			}
-		}()
-
-		// A corrupted checkpoint is a hard error for now and requires user
-		// intervention. There's likely little data that can be recovered anyway.
-		if err := h.loadWAL(wal.NewReader(sr), multiRef); err != nil {
-			return errors.Wrap(err, "backfill checkpoint")
-		}
-		startFrom++
-		level.Info(h.logger).Log("msg", "WAL checkpoint loaded")
-	}
-
-	// Find the last segment.
-	_, last, err := h.wal.Segments()
-	if err != nil {
-		return errors.Wrap(err, "finding WAL segments")
-	}
-
-	// Backfill segments from the most recent checkpoint onwards.
-	for i := startFrom; i <= last; i++ {
-		s, err := wal.OpenReadSegment(wal.SegmentName(h.wal.Dir(), i))
-		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("open WAL segment: %d", i))
-		}
-
-		sr := wal.NewSegmentBufReader(s)
-		err = h.loadWAL(wal.NewReader(sr), multiRef)
-		if err := sr.Close(); err != nil {
-			level.Warn(h.logger).Log("msg", "error while closing the wal segments reader", "err", err)
-		}
-		if err != nil {
-			return err
-		}
-		level.Info(h.logger).Log("msg", "WAL segment loaded", "segment", i, "maxSegment", last)
-	}
-
-	return nil
-}
-
-// Truncate removes old data before mint from the head.
-func (h *Head) Truncate(mint int64) (err error) {
-	defer func() {
-		if err != nil {
-			h.metrics.headTruncateFail.Inc()
-		}
-	}()
-	initialize := h.MinTime() == math.MaxInt64
-
-	if h.MinTime() >= mint && !initialize {
-		return nil
-	}
-	atomic.StoreInt64(&h.minTime, mint)
-	atomic.StoreInt64(&h.minValidTime, mint)
-
-	// Ensure that max time is at least as high as min time.
-	for h.MaxTime() < mint {
-		atomic.CompareAndSwapInt64(&h.maxTime, h.MaxTime(), mint)
-	}
-
-	// This was an initial call to Truncate after loading blocks on startup.
-	// We haven't read back the WAL yet, so do not attempt to truncate it.
-	if initialize {
-		return nil
-	}
-
-	h.metrics.headTruncateTotal.Inc()
-	start := time.Now()
-
-	h.gc()
-	level.Info(h.logger).Log("msg", "head GC completed", "duration", time.Since(start))
-	h.metrics.gcDuration.Observe(time.Since(start).Seconds())
-
-	if h.wal == nil {
-		return nil
-	}
-	start = time.Now()
-
-	first, last, err := h.wal.Segments()
-	if err != nil {
-		return errors.Wrap(err, "get segment range")
-	}
-	// Start a new segment, so low ingestion volume TSDB don't have more WAL than
-	// needed.
-	err = h.wal.NextSegment()
-	if err != nil {
-		return errors.Wrap(err, "next segment")
-	}
-	last-- // Never consider last segment for checkpoint.
-	if last < 0 {
-		return nil // no segments yet.
-	}
-	// The lower third of segments should contain mostly obsolete samples.
-	// If we have less than three segments, it's not worth checkpointing yet.
-	last = first + (last-first)/3
-	if last <= first {
-		return nil
-	}
-
-	keep := func(id uint64) bool {
-		if h.series.getByID(id) != nil {
-			return true
-		}
-		h.deletedMtx.Lock()
-		_, ok := h.deleted[id]
-		h.deletedMtx.Unlock()
-		return ok
-	}
-	h.metrics.checkpointCreationTotal.Inc()
-	if _, err = Checkpoint(h.wal, first, last, keep, mint); err != nil {
-		h.metrics.checkpointCreationFail.Inc()
-		return errors.Wrap(err, "create checkpoint")
-	}
-	if err := h.wal.Truncate(last + 1); err != nil {
-		// If truncating fails, we'll just try again at the next checkpoint.
-		// Leftover segments will just be ignored in the future if there's a checkpoint
-		// that supersedes them.
-		level.Error(h.logger).Log("msg", "truncating segments failed", "err", err)
-	}
-
-	// The checkpoint is written and segments before it is truncated, so we no
-	// longer need to track deleted series that are before it.
-	h.deletedMtx.Lock()
-	for ref, segment := range h.deleted {
-		if segment < first {
-			delete(h.deleted, ref)
-		}
-	}
-	h.deletedMtx.Unlock()
-
-	h.metrics.checkpointDeleteTotal.Inc()
-	if err := DeleteCheckpoints(h.wal.Dir(), last); err != nil {
-		// Leftover old checkpoints do not cause problems down the line beyond
-		// occupying disk space.
-		// They will just be ignored since a higher checkpoint exists.
-		level.Error(h.logger).Log("msg", "delete old checkpoints", "err", err)
-		h.metrics.checkpointDeleteFail.Inc()
-	}
-	h.metrics.walTruncateDuration.Observe(time.Since(start).Seconds())
-
-	level.Info(h.logger).Log("msg", "WAL checkpoint complete",
-		"first", first, "last", last, "duration", time.Since(start))
-
-	return nil
-}
-
-// initTime initializes a head with the first timestamp. This only needs to be called
-// for a completely fresh head with an empty WAL.
-// Returns true if the initialization took an effect.
-func (h *Head) initTime(t int64) (initialized bool) {
-	if !atomic.CompareAndSwapInt64(&h.minTime, math.MaxInt64, t) {
-		return false
-	}
-	// Ensure that max time is initialized to at least the min time we just set.
-	// Concurrent appenders may already have set it to a higher value.
-	atomic.CompareAndSwapInt64(&h.maxTime, math.MinInt64, t)
-
-	return true
-}
-
-type rangeHead struct {
-	head       *Head
-	mint, maxt int64
-}
-
-func (h *rangeHead) Index() (IndexReader, error) {
-	return h.head.indexRange(h.mint, h.maxt), nil
-}
-
-func (h *rangeHead) Chunks() (ChunkReader, error) {
-	return h.head.chunksRange(h.mint, h.maxt), nil
-}
-
-func (h *rangeHead) Tombstones() (TombstoneReader, error) {
-	return emptyTombstoneReader, nil
-}
-
-func (h *rangeHead) MinTime() int64 {
-	return h.mint
-}
-
-func (h *rangeHead) MaxTime() int64 {
-	return h.maxt
-}
-
-func (h *rangeHead) NumSeries() uint64 {
-	return h.head.NumSeries()
-}
-
-func (h *rangeHead) Meta() BlockMeta {
-	return BlockMeta{
-		MinTime: h.MinTime(),
-		MaxTime: h.MaxTime(),
-		ULID:    h.head.Meta().ULID,
-		Stats: BlockStats{
-			NumSeries: h.NumSeries(),
-		},
-	}
-}
-
-// initAppender is a helper to initialize the time bounds of the head
-// upon the first sample it receives.
-type initAppender struct {
-	app  Appender
-	head *Head
-}
-
-func (a *initAppender) Add(lset labels.Labels, t int64, v float64) (uint64, error) {
-	if a.app != nil {
-		return a.app.Add(lset, t, v)
-	}
-	a.head.initTime(t)
-	a.app = a.head.appender()
-
-	return a.app.Add(lset, t, v)
-}
-
-func (a *initAppender) AddFast(ref uint64, t int64, v float64) error {
-	if a.app == nil {
-		return ErrNotFound
-	}
-	return a.app.AddFast(ref, t, v)
-}
-
-func (a *initAppender) Commit() error {
-	if a.app == nil {
-		return nil
-	}
-	return a.app.Commit()
-}
-
-func (a *initAppender) Rollback() error {
-	if a.app == nil {
-		return nil
-	}
-	return a.app.Rollback()
-}
-
-// Appender returns a new Appender on the database.
-func (h *Head) Appender() Appender {
-	h.metrics.activeAppenders.Inc()
-
-	// The head cache might not have a starting point yet. The init appender
-	// picks up the first appended timestamp as the base.
-	if h.MinTime() == math.MaxInt64 {
-		return &initAppender{head: h}
-	}
-	return h.appender()
-}
-
-func (h *Head) appender() *headAppender {
-	return &headAppender{
-		head: h,
-		// Set the minimum valid time to whichever is greater the head min valid time or the compaciton window.
-		// This ensures that no samples will be added within the compaction window to avoid races.
-		minValidTime: max(atomic.LoadInt64(&h.minValidTime), h.MaxTime()-h.chunkRange/2),
-		mint:         math.MaxInt64,
-		maxt:         math.MinInt64,
-		samples:      h.getAppendBuffer(),
-	}
-}
-
-func max(a, b int64) int64 {
-	if a > b {
-		return a
-	}
-	return b
-}
-
-func (h *Head) getAppendBuffer() []RefSample {
-	b := h.appendPool.Get()
-	if b == nil {
-		return make([]RefSample, 0, 512)
-	}
-	return b.([]RefSample)
-}
-
-func (h *Head) putAppendBuffer(b []RefSample) {
-	//lint:ignore SA6002 safe to ignore and actually fixing it has some performance penalty.
-	h.appendPool.Put(b[:0])
-}
-
-func (h *Head) getBytesBuffer() []byte {
-	b := h.bytesPool.Get()
-	if b == nil {
-		return make([]byte, 0, 1024)
-	}
-	return b.([]byte)
-}
-
-func (h *Head) putBytesBuffer(b []byte) {
-	//lint:ignore SA6002 safe to ignore and actually fixing it has some performance penalty.
-	h.bytesPool.Put(b[:0])
-}
-
-type headAppender struct {
-	head         *Head
-	minValidTime int64 // No samples below this timestamp are allowed.
-	mint, maxt   int64
-
-	series  []RefSeries
-	samples []RefSample
-}
-
-func (a *headAppender) Add(lset labels.Labels, t int64, v float64) (uint64, error) {
-	if t < a.minValidTime {
-		return 0, ErrOutOfBounds
-	}
-
-	// Ensure no empty labels have gotten through.
-	lset = lset.WithoutEmpty()
-
-	s, created := a.head.getOrCreate(lset.Hash(), lset)
-	if created {
-		a.series = append(a.series, RefSeries{
-			Ref:    s.ref,
-			Labels: lset,
-		})
-	}
-	return s.ref, a.AddFast(s.ref, t, v)
-}
-
-func (a *headAppender) AddFast(ref uint64, t int64, v float64) error {
-	if t < a.minValidTime {
-		return ErrOutOfBounds
-	}
-
-	s := a.head.series.getByID(ref)
-	if s == nil {
-		return errors.Wrap(ErrNotFound, "unknown series")
-	}
-	s.Lock()
-	if err := s.appendable(t, v); err != nil {
-		s.Unlock()
-		return err
-	}
-	s.pendingCommit = true
-	s.Unlock()
-
-	if t < a.mint {
-		a.mint = t
-	}
-	if t > a.maxt {
-		a.maxt = t
-	}
-
-	a.samples = append(a.samples, RefSample{
-		Ref:    ref,
-		T:      t,
-		V:      v,
-		series: s,
-	})
-	return nil
-}
-
-func (a *headAppender) log() error {
-	if a.head.wal == nil {
-		return nil
-	}
-
-	buf := a.head.getBytesBuffer()
-	defer func() { a.head.putBytesBuffer(buf) }()
-
-	var rec []byte
-	var enc RecordEncoder
-
-	if len(a.series) > 0 {
-		rec = enc.Series(a.series, buf)
-		buf = rec[:0]
-
-		if err := a.head.wal.Log(rec); err != nil {
-			return errors.Wrap(err, "log series")
-		}
-	}
-	if len(a.samples) > 0 {
-		rec = enc.Samples(a.samples, buf)
-		buf = rec[:0]
-
-		if err := a.head.wal.Log(rec); err != nil {
-			return errors.Wrap(err, "log samples")
-		}
-	}
-	return nil
-}
-
-func (a *headAppender) Commit() error {
-	defer a.head.metrics.activeAppenders.Dec()
-	defer a.head.putAppendBuffer(a.samples)
-
-	if err := a.log(); err != nil {
-		return errors.Wrap(err, "write to WAL")
-	}
-
-	total := len(a.samples)
-
-	for _, s := range a.samples {
-		s.series.Lock()
-		ok, chunkCreated := s.series.append(s.T, s.V)
-		s.series.pendingCommit = false
-		s.series.Unlock()
-
-		if !ok {
-			total--
-		}
-		if chunkCreated {
-			a.head.metrics.chunks.Inc()
-			a.head.metrics.chunksCreated.Inc()
-		}
-	}
-
-	a.head.metrics.samplesAppended.Add(float64(total))
-	a.head.updateMinMaxTime(a.mint, a.maxt)
-
-	return nil
-}
-
-func (a *headAppender) Rollback() error {
-	a.head.metrics.activeAppenders.Dec()
-	for _, s := range a.samples {
-		s.series.Lock()
-		s.series.pendingCommit = false
-		s.series.Unlock()
-	}
-	a.head.putAppendBuffer(a.samples)
-
-	// Series are created in the head memory regardless of rollback. Thus we have
-	// to log them to the WAL in any case.
-	a.samples = nil
-	return a.log()
-}
-
-// Delete all samples in the range of [mint, maxt] for series that satisfy the given
-// label matchers.
-func (h *Head) Delete(mint, maxt int64, ms ...labels.Matcher) error {
-	// Do not delete anything beyond the currently valid range.
-	mint, maxt = clampInterval(mint, maxt, h.MinTime(), h.MaxTime())
-
-	ir := h.indexRange(mint, maxt)
-
-	p, err := PostingsForMatchers(ir, ms...)
-	if err != nil {
-		return errors.Wrap(err, "select series")
-	}
-
-	var stones []Stone
-	dirty := false
-	for p.Next() {
-		series := h.series.getByID(p.At())
-
-		t0, t1 := series.minTime(), series.maxTime()
-		if t0 == math.MinInt64 || t1 == math.MinInt64 {
-			continue
-		}
-		// Delete only until the current values and not beyond.
-		t0, t1 = clampInterval(mint, maxt, t0, t1)
-		if h.wal != nil {
-			stones = append(stones, Stone{p.At(), Intervals{{t0, t1}}})
-		}
-		if err := h.chunkRewrite(p.At(), Intervals{{t0, t1}}); err != nil {
-			return errors.Wrap(err, "delete samples")
-		}
-		dirty = true
-	}
-	if p.Err() != nil {
-		return p.Err()
-	}
-	var enc RecordEncoder
-	if h.wal != nil {
-		// Although we don't store the stones in the head
-		// we need to write them to the WAL to mark these as deleted
-		// after a restart while loading the WAL.
-		if err := h.wal.Log(enc.Tombstones(stones, nil)); err != nil {
-			return err
-		}
-	}
-	if dirty {
-		h.gc()
-	}
-
-	return nil
-}
-
-// chunkRewrite re-writes the chunks which overlaps with deleted ranges
-// and removes the samples in the deleted ranges.
-// Chunks is deleted if no samples are left at the end.
-func (h *Head) chunkRewrite(ref uint64, dranges Intervals) (err error) {
-	if len(dranges) == 0 {
-		return nil
-	}
-
-	ms := h.series.getByID(ref)
-	ms.Lock()
-	defer ms.Unlock()
-	if len(ms.chunks) == 0 {
-		return nil
-	}
-
-	metas := ms.chunksMetas()
-	mint, maxt := metas[0].MinTime, metas[len(metas)-1].MaxTime
-	it := newChunkSeriesIterator(metas, dranges, mint, maxt)
-
-	ms.reset()
-	for it.Next() {
-		t, v := it.At()
-		ok, _ := ms.append(t, v)
-		if !ok {
-			level.Warn(h.logger).Log("msg", "failed to add sample during delete")
-		}
-	}
-
-	return nil
-}
-
-// gc removes data before the minimum timestamp from the head.
-func (h *Head) gc() {
-	// Only data strictly lower than this timestamp must be deleted.
-	mint := h.MinTime()
-
-	// Drop old chunks and remember series IDs and hashes if they can be
-	// deleted entirely.
-	deleted, chunksRemoved := h.series.gc(mint)
-	seriesRemoved := len(deleted)
-
-	h.metrics.seriesRemoved.Add(float64(seriesRemoved))
-	h.metrics.chunksRemoved.Add(float64(chunksRemoved))
-	h.metrics.chunks.Sub(float64(chunksRemoved))
-	// Using AddUint64 to substract series removed.
-	// See: https://golang.org/pkg/sync/atomic/#AddUint64.
-	atomic.AddUint64(&h.numSeries, ^uint64(seriesRemoved-1))
-
-	// Remove deleted series IDs from the postings lists.
-	h.postings.Delete(deleted)
-
-	if h.wal != nil {
-		_, last, _ := h.wal.Segments()
-		h.deletedMtx.Lock()
-		// Keep series records until we're past segment 'last'
-		// because the WAL will still have samples records with
-		// this ref ID. If we didn't keep these series records then
-		// on start up when we replay the WAL, or any other code
-		// that reads the WAL, wouldn't be able to use those
-		// samples since we would have no labels for that ref ID.
-		for ref := range deleted {
-			h.deleted[ref] = last
-		}
-		h.deletedMtx.Unlock()
-	}
-
-	// Rebuild symbols and label value indices from what is left in the postings terms.
-	symbols := make(map[string]struct{}, len(h.symbols))
-	values := make(map[string]stringset, len(h.values))
-
-	if err := h.postings.Iter(func(t labels.Label, _ index.Postings) error {
-		symbols[t.Name] = struct{}{}
-		symbols[t.Value] = struct{}{}
-
-		ss, ok := values[t.Name]
-		if !ok {
-			ss = stringset{}
-			values[t.Name] = ss
-		}
-		ss.set(t.Value)
-		return nil
-	}); err != nil {
-		// This should never happen, as the iteration function only returns nil.
-		panic(err)
-	}
-
-	h.symMtx.Lock()
-
-	h.symbols = symbols
-	h.values = values
-
-	h.symMtx.Unlock()
-}
-
-// Tombstones returns a new reader over the head's tombstones
-func (h *Head) Tombstones() (TombstoneReader, error) {
-	return emptyTombstoneReader, nil
-}
-
-// Index returns an IndexReader against the block.
-func (h *Head) Index() (IndexReader, error) {
-	return h.indexRange(math.MinInt64, math.MaxInt64), nil
-}
-
-func (h *Head) indexRange(mint, maxt int64) *headIndexReader {
-	if hmin := h.MinTime(); hmin > mint {
-		mint = hmin
-	}
-	return &headIndexReader{head: h, mint: mint, maxt: maxt}
-}
-
-// Chunks returns a ChunkReader against the block.
-func (h *Head) Chunks() (ChunkReader, error) {
-	return h.chunksRange(math.MinInt64, math.MaxInt64), nil
-}
-
-func (h *Head) chunksRange(mint, maxt int64) *headChunkReader {
-	if hmin := h.MinTime(); hmin > mint {
-		mint = hmin
-	}
-	return &headChunkReader{head: h, mint: mint, maxt: maxt}
-}
-
-// NumSeries returns the number of active series in the head.
-func (h *Head) NumSeries() uint64 {
-	return atomic.LoadUint64(&h.numSeries)
-}
-
-// Meta returns meta information about the head.
-// The head is dynamic so will return dynamic results.
-func (h *Head) Meta() BlockMeta {
-	var id [16]byte
-	copy(id[:], "______head______")
-	return BlockMeta{
-		MinTime: h.MinTime(),
-		MaxTime: h.MaxTime(),
-		ULID:    ulid.ULID(id),
-		Stats: BlockStats{
-			NumSeries: h.NumSeries(),
-		},
-	}
-}
-
-// MinTime returns the lowest time bound on visible data in the head.
-func (h *Head) MinTime() int64 {
-	return atomic.LoadInt64(&h.minTime)
-}
-
-// MaxTime returns the highest timestamp seen in data of the head.
-func (h *Head) MaxTime() int64 {
-	return atomic.LoadInt64(&h.maxTime)
-}
-
-// compactable returns whether the head has a compactable range.
-// The head has a compactable range when the head time range is 1.5 times the chunk range.
-// The 0.5 acts as a buffer of the appendable window.
-func (h *Head) compactable() bool {
-	return h.MaxTime()-h.MinTime() > h.chunkRange/2*3
-}
-
-// Close flushes the WAL and closes the head.
-func (h *Head) Close() error {
-	if h.wal == nil {
-		return nil
-	}
-	return h.wal.Close()
-}
-
-type headChunkReader struct {
-	head       *Head
-	mint, maxt int64
-}
-
-func (h *headChunkReader) Close() error {
-	return nil
-}
-
-// packChunkID packs a seriesID and a chunkID within it into a global 8 byte ID.
-// It panicks if the seriesID exceeds 5 bytes or the chunk ID 3 bytes.
-func packChunkID(seriesID, chunkID uint64) uint64 {
-	if seriesID > (1<<40)-1 {
-		panic("series ID exceeds 5 bytes")
-	}
-	if chunkID > (1<<24)-1 {
-		panic("chunk ID exceeds 3 bytes")
-	}
-	return (seriesID << 24) | chunkID
-}
-
-func unpackChunkID(id uint64) (seriesID, chunkID uint64) {
-	return id >> 24, (id << 40) >> 40
-}
-
-// Chunk returns the chunk for the reference number.
-func (h *headChunkReader) Chunk(ref uint64) (chunkenc.Chunk, error) {
-	sid, cid := unpackChunkID(ref)
-
-	s := h.head.series.getByID(sid)
-	// This means that the series has been garbage collected.
-	if s == nil {
-		return nil, ErrNotFound
-	}
-
-	s.Lock()
-	c := s.chunk(int(cid))
-
-	// This means that the chunk has been garbage collected or is outside
-	// the specified range.
-	if c == nil || !c.OverlapsClosedInterval(h.mint, h.maxt) {
-		s.Unlock()
-		return nil, ErrNotFound
-	}
-	s.Unlock()
-
-	return &safeChunk{
-		Chunk: c.chunk,
-		s:     s,
-		cid:   int(cid),
-	}, nil
-}
-
-type safeChunk struct {
-	chunkenc.Chunk
-	s   *memSeries
-	cid int
-}
-
-func (c *safeChunk) Iterator(reuseIter chunkenc.Iterator) chunkenc.Iterator {
-	c.s.Lock()
-	it := c.s.iterator(c.cid, reuseIter)
-	c.s.Unlock()
-	return it
-}
-
-type headIndexReader struct {
-	head       *Head
-	mint, maxt int64
-}
-
-func (h *headIndexReader) Close() error {
-	return nil
-}
-
-func (h *headIndexReader) Symbols() (map[string]struct{}, error) {
-	h.head.symMtx.RLock()
-	defer h.head.symMtx.RUnlock()
-
-	res := make(map[string]struct{}, len(h.head.symbols))
-
-	for s := range h.head.symbols {
-		res[s] = struct{}{}
-	}
-	return res, nil
-}
-
-// LabelValues returns the possible label values
-func (h *headIndexReader) LabelValues(names ...string) (index.StringTuples, error) {
-	if len(names) != 1 {
-		return nil, encoding.ErrInvalidSize
-	}
-
-	h.head.symMtx.RLock()
-	sl := make([]string, 0, len(h.head.values[names[0]]))
-	for s := range h.head.values[names[0]] {
-		sl = append(sl, s)
-	}
-	h.head.symMtx.RUnlock()
-	sort.Strings(sl)
-
-	return index.NewStringTuples(sl, len(names))
-}
-
-// LabelNames returns all the unique label names present in the head.
-func (h *headIndexReader) LabelNames() ([]string, error) {
-	h.head.symMtx.RLock()
-	defer h.head.symMtx.RUnlock()
-	labelNames := make([]string, 0, len(h.head.values))
-	for name := range h.head.values {
-		if name == "" {
-			continue
-		}
-		labelNames = append(labelNames, name)
-	}
-	sort.Strings(labelNames)
-	return labelNames, nil
-}
-
-// Postings returns the postings list iterator for the label pair.
-func (h *headIndexReader) Postings(name, value string) (index.Postings, error) {
-	return h.head.postings.Get(name, value), nil
-}
-
-func (h *headIndexReader) SortedPostings(p index.Postings) index.Postings {
-	series := make([]*memSeries, 0, 128)
-
-	// Fetch all the series only once.
-	for p.Next() {
-		s := h.head.series.getByID(p.At())
-		if s == nil {
-			level.Debug(h.head.logger).Log("msg", "looked up series not found")
-		} else {
-			series = append(series, s)
-		}
-	}
-	if err := p.Err(); err != nil {
-		return index.ErrPostings(errors.Wrap(err, "expand postings"))
-	}
-
-	sort.Slice(series, func(i, j int) bool {
-		return labels.Compare(series[i].lset, series[j].lset) < 0
-	})
-
-	// Convert back to list.
-	ep := make([]uint64, 0, len(series))
-	for _, p := range series {
-		ep = append(ep, p.ref)
-	}
-	return index.NewListPostings(ep)
-}
-
-// Series returns the series for the given reference.
-func (h *headIndexReader) Series(ref uint64, lbls *labels.Labels, chks *[]chunks.Meta) error {
-	s := h.head.series.getByID(ref)
-
-	if s == nil {
-		h.head.metrics.seriesNotFound.Inc()
-		return ErrNotFound
-	}
-	*lbls = append((*lbls)[:0], s.lset...)
-
-	s.Lock()
-	defer s.Unlock()
-
-	*chks = (*chks)[:0]
-
-	for i, c := range s.chunks {
-		// Do not expose chunks that are outside of the specified range.
-		if !c.OverlapsClosedInterval(h.mint, h.maxt) {
-			continue
-		}
-		// Set the head chunks as open (being appended to).
-		maxTime := c.maxTime
-		if s.headChunk == c {
-			maxTime = math.MaxInt64
-		}
-
-		*chks = append(*chks, chunks.Meta{
-			MinTime: c.minTime,
-			MaxTime: maxTime,
-			Ref:     packChunkID(s.ref, uint64(s.chunkID(i))),
-		})
-	}
-
-	return nil
-}
-
-func (h *headIndexReader) LabelIndices() ([][]string, error) {
-	h.head.symMtx.RLock()
-	defer h.head.symMtx.RUnlock()
-	res := [][]string{}
-	for s := range h.head.values {
-		res = append(res, []string{s})
-	}
-	return res, nil
-}
-
-func (h *Head) getOrCreate(hash uint64, lset labels.Labels) (*memSeries, bool) {
-	// Just using `getOrSet` below would be semantically sufficient, but we'd create
-	// a new series on every sample inserted via Add(), which causes allocations
-	// and makes our series IDs rather random and harder to compress in postings.
-	s := h.series.getByHash(hash, lset)
-	if s != nil {
-		return s, false
-	}
-
-	// Optimistically assume that we are the first one to create the series.
-	id := atomic.AddUint64(&h.lastSeriesID, 1)
-
-	return h.getOrCreateWithID(id, hash, lset)
-}
-
-func (h *Head) getOrCreateWithID(id, hash uint64, lset labels.Labels) (*memSeries, bool) {
-	s := newMemSeries(lset, id, h.chunkRange)
-
-	s, created := h.series.getOrSet(hash, s)
-	if !created {
-		return s, false
-	}
-
-	h.metrics.seriesCreated.Inc()
-	atomic.AddUint64(&h.numSeries, 1)
-
-	h.postings.Add(id, lset)
-
-	h.symMtx.Lock()
-	defer h.symMtx.Unlock()
-
-	for _, l := range lset {
-		valset, ok := h.values[l.Name]
-		if !ok {
-			valset = stringset{}
-			h.values[l.Name] = valset
-		}
-		valset.set(l.Value)
-
-		h.symbols[l.Name] = struct{}{}
-		h.symbols[l.Value] = struct{}{}
-	}
-
-	return s, true
-}
-
-// seriesHashmap is a simple hashmap for memSeries by their label set. It is built
-// on top of a regular hashmap and holds a slice of series to resolve hash collisions.
-// Its methods require the hash to be submitted with it to avoid re-computations throughout
-// the code.
-type seriesHashmap map[uint64][]*memSeries
-
-func (m seriesHashmap) get(hash uint64, lset labels.Labels) *memSeries {
-	for _, s := range m[hash] {
-		if s.lset.Equals(lset) {
-			return s
-		}
-	}
-	return nil
-}
-
-func (m seriesHashmap) set(hash uint64, s *memSeries) {
-	l := m[hash]
-	for i, prev := range l {
-		if prev.lset.Equals(s.lset) {
-			l[i] = s
-			return
-		}
-	}
-	m[hash] = append(l, s)
-}
-
-func (m seriesHashmap) del(hash uint64, lset labels.Labels) {
-	var rem []*memSeries
-	for _, s := range m[hash] {
-		if !s.lset.Equals(lset) {
-			rem = append(rem, s)
-		}
-	}
-	if len(rem) == 0 {
-		delete(m, hash)
-	} else {
-		m[hash] = rem
-	}
-}
-
-// stripeSeries locks modulo ranges of IDs and hashes to reduce lock contention.
-// The locks are padded to not be on the same cache line. Filling the padded space
-// with the maps was profiled to be slower – likely due to the additional pointer
-// dereferences.
-type stripeSeries struct {
-	series [stripeSize]map[uint64]*memSeries
-	hashes [stripeSize]seriesHashmap
-	locks  [stripeSize]stripeLock
-}
-
-const (
-	stripeSize = 1 << 14
-	stripeMask = stripeSize - 1
-)
-
-type stripeLock struct {
-	sync.RWMutex
-	// Padding to avoid multiple locks being on the same cache line.
-	_ [40]byte
-}
-
-func newStripeSeries() *stripeSeries {
-	s := &stripeSeries{}
-
-	for i := range s.series {
-		s.series[i] = map[uint64]*memSeries{}
-	}
-	for i := range s.hashes {
-		s.hashes[i] = seriesHashmap{}
-	}
-	return s
-}
-
-// gc garbage collects old chunks that are strictly before mint and removes
-// series entirely that have no chunks left.
-func (s *stripeSeries) gc(mint int64) (map[uint64]struct{}, int) {
-	var (
-		deleted  = map[uint64]struct{}{}
-		rmChunks = 0
-	)
-	// Run through all series and truncate old chunks. Mark those with no
-	// chunks left as deleted and store their ID.
-	for i := 0; i < stripeSize; i++ {
-		s.locks[i].Lock()
-
-		for hash, all := range s.hashes[i] {
-			for _, series := range all {
-				series.Lock()
-				rmChunks += series.truncateChunksBefore(mint)
-
-				if len(series.chunks) > 0 || series.pendingCommit {
-					series.Unlock()
-					continue
-				}
-
-				// The series is gone entirely. We need to keep the series lock
-				// and make sure we have acquired the stripe locks for hash and ID of the
-				// series alike.
-				// If we don't hold them all, there's a very small chance that a series receives
-				// samples again while we are half-way into deleting it.
-				j := int(series.ref & stripeMask)
-
-				if i != j {
-					s.locks[j].Lock()
-				}
-
-				deleted[series.ref] = struct{}{}
-				s.hashes[i].del(hash, series.lset)
-				delete(s.series[j], series.ref)
-
-				if i != j {
-					s.locks[j].Unlock()
-				}
-
-				series.Unlock()
-			}
-		}
-
-		s.locks[i].Unlock()
-	}
-
-	return deleted, rmChunks
-}
-
-func (s *stripeSeries) getByID(id uint64) *memSeries {
-	i := id & stripeMask
-
-	s.locks[i].RLock()
-	series := s.series[i][id]
-	s.locks[i].RUnlock()
-
-	return series
-}
-
-func (s *stripeSeries) getByHash(hash uint64, lset labels.Labels) *memSeries {
-	i := hash & stripeMask
-
-	s.locks[i].RLock()
-	series := s.hashes[i].get(hash, lset)
-	s.locks[i].RUnlock()
-
-	return series
-}
-
-func (s *stripeSeries) getOrSet(hash uint64, series *memSeries) (*memSeries, bool) {
-	i := hash & stripeMask
-
-	s.locks[i].Lock()
-
-	if prev := s.hashes[i].get(hash, series.lset); prev != nil {
-		s.locks[i].Unlock()
-		return prev, false
-	}
-	s.hashes[i].set(hash, series)
-	s.locks[i].Unlock()
-
-	i = series.ref & stripeMask
-
-	s.locks[i].Lock()
-	s.series[i][series.ref] = series
-	s.locks[i].Unlock()
-
-	return series, true
-}
-
-type sample struct {
-	t int64
-	v float64
-}
-
-func (s sample) T() int64 {
-	return s.t
-}
-
-func (s sample) V() float64 {
-	return s.v
-}
-
-// memSeries is the in-memory representation of a series. None of its methods
-// are goroutine safe and it is the caller's responsibility to lock it.
-type memSeries struct {
-	sync.Mutex
-
-	ref          uint64
-	lset         labels.Labels
-	chunks       []*memChunk
-	headChunk    *memChunk
-	chunkRange   int64
-	firstChunkID int
-
-	nextAt        int64 // Timestamp at which to cut the next chunk.
-	sampleBuf     [4]sample
-	pendingCommit bool // Whether there are samples waiting to be committed to this series.
-
-	app chunkenc.Appender // Current appender for the chunk.
-}
-
-func newMemSeries(lset labels.Labels, id uint64, chunkRange int64) *memSeries {
-	s := &memSeries{
-		lset:       lset,
-		ref:        id,
-		chunkRange: chunkRange,
-		nextAt:     math.MinInt64,
-	}
-	return s
-}
-
-func (s *memSeries) minTime() int64 {
-	if len(s.chunks) == 0 {
-		return math.MinInt64
-	}
-	return s.chunks[0].minTime
-}
-
-func (s *memSeries) maxTime() int64 {
-	c := s.head()
-	if c == nil {
-		return math.MinInt64
-	}
-	return c.maxTime
-}
-
-func (s *memSeries) cut(mint int64) *memChunk {
-	c := &memChunk{
-		chunk:   chunkenc.NewXORChunk(),
-		minTime: mint,
-		maxTime: math.MinInt64,
-	}
-	s.chunks = append(s.chunks, c)
-	s.headChunk = c
-
-	// Set upper bound on when the next chunk must be started. An earlier timestamp
-	// may be chosen dynamically at a later point.
-	s.nextAt = rangeForTimestamp(mint, s.chunkRange)
-
-	app, err := c.chunk.Appender()
-	if err != nil {
-		panic(err)
-	}
-	s.app = app
-	return c
-}
-
-func (s *memSeries) chunksMetas() []chunks.Meta {
-	metas := make([]chunks.Meta, 0, len(s.chunks))
-	for _, chk := range s.chunks {
-		metas = append(metas, chunks.Meta{Chunk: chk.chunk, MinTime: chk.minTime, MaxTime: chk.maxTime})
-	}
-	return metas
-}
-
-// reset re-initialises all the variable in the memSeries except 'lset', 'ref',
-// and 'chunkRange', like how it would appear after 'newMemSeries(...)'.
-func (s *memSeries) reset() {
-	s.chunks = nil
-	s.headChunk = nil
-	s.firstChunkID = 0
-	s.nextAt = math.MinInt64
-	s.sampleBuf = [4]sample{}
-	s.pendingCommit = false
-	s.app = nil
-}
-
-// appendable checks whether the given sample is valid for appending to the series.
-func (s *memSeries) appendable(t int64, v float64) error {
-	c := s.head()
-	if c == nil {
-		return nil
-	}
-
-	if t > c.maxTime {
-		return nil
-	}
-	if t < c.maxTime {
-		return ErrOutOfOrderSample
-	}
-	// We are allowing exact duplicates as we can encounter them in valid cases
-	// like federation and erroring out at that time would be extremely noisy.
-	if math.Float64bits(s.sampleBuf[3].v) != math.Float64bits(v) {
-		return ErrAmendSample
-	}
-	return nil
-}
-
-func (s *memSeries) chunk(id int) *memChunk {
-	ix := id - s.firstChunkID
-	if ix < 0 || ix >= len(s.chunks) {
-		return nil
-	}
-	return s.chunks[ix]
-}
-
-func (s *memSeries) chunkID(pos int) int {
-	return pos + s.firstChunkID
-}
-
-// truncateChunksBefore removes all chunks from the series that have not timestamp
-// at or after mint. Chunk IDs remain unchanged.
-func (s *memSeries) truncateChunksBefore(mint int64) (removed int) {
-	var k int
-	for i, c := range s.chunks {
-		if c.maxTime >= mint {
-			break
-		}
-		k = i + 1
-	}
-	s.chunks = append(s.chunks[:0], s.chunks[k:]...)
-	s.firstChunkID += k
-	if len(s.chunks) == 0 {
-		s.headChunk = nil
-	} else {
-		s.headChunk = s.chunks[len(s.chunks)-1]
-	}
-
-	return k
-}
-
-// append adds the sample (t, v) to the series.
-func (s *memSeries) append(t int64, v float64) (success, chunkCreated bool) {
-	// Based on Gorilla white papers this offers near-optimal compression ratio
-	// so anything bigger that this has diminishing returns and increases
-	// the time range within which we have to decompress all samples.
-	const samplesPerChunk = 120
-
-	c := s.head()
-
-	if c == nil {
-		c = s.cut(t)
-		chunkCreated = true
-	}
-	numSamples := c.chunk.NumSamples()
-
-	// Out of order sample.
-	if c.maxTime >= t {
-		return false, chunkCreated
-	}
-	// If we reach 25% of a chunk's desired sample count, set a definitive time
-	// at which to start the next chunk.
-	// At latest it must happen at the timestamp set when the chunk was cut.
-	if numSamples == samplesPerChunk/4 {
-		s.nextAt = computeChunkEndTime(c.minTime, c.maxTime, s.nextAt)
-	}
-	if t >= s.nextAt {
-		c = s.cut(t)
-		chunkCreated = true
-	}
-	s.app.Append(t, v)
-
-	c.maxTime = t
-
-	s.sampleBuf[0] = s.sampleBuf[1]
-	s.sampleBuf[1] = s.sampleBuf[2]
-	s.sampleBuf[2] = s.sampleBuf[3]
-	s.sampleBuf[3] = sample{t: t, v: v}
-
-	return true, chunkCreated
-}
-
-// computeChunkEndTime estimates the end timestamp based the beginning of a chunk,
-// its current timestamp and the upper bound up to which we insert data.
-// It assumes that the time range is 1/4 full.
-func computeChunkEndTime(start, cur, max int64) int64 {
-	a := (max - start) / ((cur - start + 1) * 4)
-	if a == 0 {
-		return max
-	}
-	return start + (max-start)/a
-}
-
-func (s *memSeries) iterator(id int, it chunkenc.Iterator) chunkenc.Iterator {
-	c := s.chunk(id)
-	// TODO(fabxc): Work around! A querier may have retrieved a pointer to a series' chunk,
-	// which got then garbage collected before it got accessed.
-	// We must ensure to not garbage collect as long as any readers still hold a reference.
-	if c == nil {
-		return chunkenc.NewNopIterator()
-	}
-
-	if id-s.firstChunkID < len(s.chunks)-1 {
-		return c.chunk.Iterator(it)
-	}
-	// Serve the last 4 samples for the last chunk from the sample buffer
-	// as their compressed bytes may be mutated by added samples.
-	if msIter, ok := it.(*memSafeIterator); ok {
-		msIter.Iterator = c.chunk.Iterator(msIter.Iterator)
-		msIter.i = -1
-		msIter.total = c.chunk.NumSamples()
-		msIter.buf = s.sampleBuf
-		return msIter
-	}
-	return &memSafeIterator{
-		Iterator: c.chunk.Iterator(it),
-		i:        -1,
-		total:    c.chunk.NumSamples(),
-		buf:      s.sampleBuf,
-	}
-}
-
-func (s *memSeries) head() *memChunk {
-	return s.headChunk
-}
-
-type memChunk struct {
-	chunk            chunkenc.Chunk
-	minTime, maxTime int64
-}
-
-// Returns true if the chunk overlaps [mint, maxt].
-func (mc *memChunk) OverlapsClosedInterval(mint, maxt int64) bool {
-	return mc.minTime <= maxt && mint <= mc.maxTime
-}
-
-type memSafeIterator struct {
-	chunkenc.Iterator
-
-	i     int
-	total int
-	buf   [4]sample
-}
-
-func (it *memSafeIterator) Next() bool {
-	if it.i+1 >= it.total {
-		return false
-	}
-	it.i++
-	if it.total-it.i > 4 {
-		return it.Iterator.Next()
-	}
-	return true
-}
-
-func (it *memSafeIterator) At() (int64, float64) {
-	if it.total-it.i > 4 {
-		return it.Iterator.At()
-	}
-	s := it.buf[4-(it.total-it.i)]
-	return s.t, s.v
-}
-
-type stringset map[string]struct{}
-
-func (ss stringset) set(s string) {
-	ss[s] = struct{}{}
-}
-
-func (ss stringset) String() string {
-	return strings.Join(ss.slice(), ",")
-}
-
-func (ss stringset) slice() []string {
-	slice := make([]string, 0, len(ss))
-	for k := range ss {
-		slice = append(slice, k)
-	}
-	sort.Strings(slice)
-	return slice
-}
diff --git a/vendor/github.com/prometheus/tsdb/index/index.go b/vendor/github.com/prometheus/tsdb/index/index.go
deleted file mode 100644
index 1a1e9bf309..0000000000
--- a/vendor/github.com/prometheus/tsdb/index/index.go
+++ /dev/null
@@ -1,1134 +0,0 @@
-// Copyright 2017 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.
-
-package index
-
-import (
-	"bufio"
-	"encoding/binary"
-	"hash"
-	"hash/crc32"
-	"io"
-	"io/ioutil"
-	"math"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-
-	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/chunks"
-	"github.com/prometheus/tsdb/encoding"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/labels"
-)
-
-const (
-	// MagicIndex 4 bytes at the head of an index file.
-	MagicIndex = 0xBAAAD700
-	// HeaderLen represents number of bytes reserved of index for header.
-	HeaderLen = 5
-
-	// FormatV1 represents 1 version of index.
-	FormatV1 = 1
-	// FormatV2 represents 2 version of index.
-	FormatV2 = 2
-
-	labelNameSeperator = "\xff"
-
-	indexFilename = "index"
-)
-
-type indexWriterSeries struct {
-	labels labels.Labels
-	chunks []chunks.Meta // series file offset of chunks
-}
-
-type indexWriterSeriesSlice []*indexWriterSeries
-
-func (s indexWriterSeriesSlice) Len() int      { return len(s) }
-func (s indexWriterSeriesSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
-
-func (s indexWriterSeriesSlice) Less(i, j int) bool {
-	return labels.Compare(s[i].labels, s[j].labels) < 0
-}
-
-type indexWriterStage uint8
-
-const (
-	idxStageNone indexWriterStage = iota
-	idxStageSymbols
-	idxStageSeries
-	idxStageLabelIndex
-	idxStagePostings
-	idxStageDone
-)
-
-func (s indexWriterStage) String() string {
-	switch s {
-	case idxStageNone:
-		return "none"
-	case idxStageSymbols:
-		return "symbols"
-	case idxStageSeries:
-		return "series"
-	case idxStageLabelIndex:
-		return "label index"
-	case idxStagePostings:
-		return "postings"
-	case idxStageDone:
-		return "done"
-	}
-	return "<unknown>"
-}
-
-// The table gets initialized with sync.Once but may still cause a race
-// with any other use of the crc32 package anywhere. Thus we initialize it
-// before.
-var castagnoliTable *crc32.Table
-
-func init() {
-	castagnoliTable = crc32.MakeTable(crc32.Castagnoli)
-}
-
-// newCRC32 initializes a CRC32 hash with a preconfigured polynomial, so the
-// polynomial may be easily changed in one location at a later time, if necessary.
-func newCRC32() hash.Hash32 {
-	return crc32.New(castagnoliTable)
-}
-
-// Writer implements the IndexWriter interface for the standard
-// serialization format.
-type Writer struct {
-	f    *os.File
-	fbuf *bufio.Writer
-	pos  uint64
-
-	toc   TOC
-	stage indexWriterStage
-
-	// Reusable memory.
-	buf1    encoding.Encbuf
-	buf2    encoding.Encbuf
-	uint32s []uint32
-
-	symbols       map[string]uint32     // symbol offsets
-	seriesOffsets map[uint64]uint64     // offsets of series
-	labelIndexes  []labelIndexHashEntry // label index offsets
-	postings      []postingsHashEntry   // postings lists offsets
-
-	// Hold last series to validate that clients insert new series in order.
-	lastSeries labels.Labels
-
-	crc32 hash.Hash
-
-	Version int
-}
-
-// TOC represents index Table Of Content that states where each section of index starts.
-type TOC struct {
-	Symbols           uint64
-	Series            uint64
-	LabelIndices      uint64
-	LabelIndicesTable uint64
-	Postings          uint64
-	PostingsTable     uint64
-}
-
-// NewTOCFromByteSlice return parsed TOC from given index byte slice.
-func NewTOCFromByteSlice(bs ByteSlice) (*TOC, error) {
-	if bs.Len() < indexTOCLen {
-		return nil, encoding.ErrInvalidSize
-	}
-	b := bs.Range(bs.Len()-indexTOCLen, bs.Len())
-
-	expCRC := binary.BigEndian.Uint32(b[len(b)-4:])
-	d := encoding.Decbuf{B: b[:len(b)-4]}
-
-	if d.Crc32(castagnoliTable) != expCRC {
-		return nil, errors.Wrap(encoding.ErrInvalidChecksum, "read TOC")
-	}
-
-	if err := d.Err(); err != nil {
-		return nil, err
-	}
-
-	return &TOC{
-		Symbols:           d.Be64(),
-		Series:            d.Be64(),
-		LabelIndices:      d.Be64(),
-		LabelIndicesTable: d.Be64(),
-		Postings:          d.Be64(),
-		PostingsTable:     d.Be64(),
-	}, nil
-}
-
-// NewWriter returns a new Writer to the given filename. It serializes data in format version 2.
-func NewWriter(fn string) (*Writer, error) {
-	dir := filepath.Dir(fn)
-
-	df, err := fileutil.OpenDir(dir)
-	if err != nil {
-		return nil, err
-	}
-	defer df.Close() // Close for platform windows.
-
-	if err := os.RemoveAll(fn); err != nil {
-		return nil, errors.Wrap(err, "remove any existing index at path")
-	}
-
-	f, err := os.OpenFile(fn, os.O_CREATE|os.O_WRONLY, 0666)
-	if err != nil {
-		return nil, err
-	}
-	if err := df.Sync(); err != nil {
-		return nil, errors.Wrap(err, "sync dir")
-	}
-
-	iw := &Writer{
-		f:     f,
-		fbuf:  bufio.NewWriterSize(f, 1<<22),
-		pos:   0,
-		stage: idxStageNone,
-
-		// Reusable memory.
-		buf1:    encoding.Encbuf{B: make([]byte, 0, 1<<22)},
-		buf2:    encoding.Encbuf{B: make([]byte, 0, 1<<22)},
-		uint32s: make([]uint32, 0, 1<<15),
-
-		// Caches.
-		symbols:       make(map[string]uint32, 1<<13),
-		seriesOffsets: make(map[uint64]uint64, 1<<16),
-		crc32:         newCRC32(),
-	}
-	if err := iw.writeMeta(); err != nil {
-		return nil, err
-	}
-	return iw, nil
-}
-
-func (w *Writer) write(bufs ...[]byte) error {
-	for _, b := range bufs {
-		n, err := w.fbuf.Write(b)
-		w.pos += uint64(n)
-		if err != nil {
-			return err
-		}
-		// For now the index file must not grow beyond 64GiB. Some of the fixed-sized
-		// offset references in v1 are only 4 bytes large.
-		// Once we move to compressed/varint representations in those areas, this limitation
-		// can be lifted.
-		if w.pos > 16*math.MaxUint32 {
-			return errors.Errorf("exceeding max size of 64GiB")
-		}
-	}
-	return nil
-}
-
-// addPadding adds zero byte padding until the file size is a multiple size.
-func (w *Writer) addPadding(size int) error {
-	p := w.pos % uint64(size)
-	if p == 0 {
-		return nil
-	}
-	p = uint64(size) - p
-	return errors.Wrap(w.write(make([]byte, p)), "add padding")
-}
-
-// ensureStage handles transitions between write stages and ensures that IndexWriter
-// methods are called in an order valid for the implementation.
-func (w *Writer) ensureStage(s indexWriterStage) error {
-	if w.stage == s {
-		return nil
-	}
-	if w.stage > s {
-		return errors.Errorf("invalid stage %q, currently at %q", s, w.stage)
-	}
-
-	// Mark start of sections in table of contents.
-	switch s {
-	case idxStageSymbols:
-		w.toc.Symbols = w.pos
-	case idxStageSeries:
-		w.toc.Series = w.pos
-
-	case idxStageLabelIndex:
-		w.toc.LabelIndices = w.pos
-
-	case idxStagePostings:
-		w.toc.Postings = w.pos
-
-	case idxStageDone:
-		w.toc.LabelIndicesTable = w.pos
-		if err := w.writeLabelIndexesOffsetTable(); err != nil {
-			return err
-		}
-		w.toc.PostingsTable = w.pos
-		if err := w.writePostingsOffsetTable(); err != nil {
-			return err
-		}
-		if err := w.writeTOC(); err != nil {
-			return err
-		}
-	}
-
-	w.stage = s
-	return nil
-}
-
-func (w *Writer) writeMeta() error {
-	w.buf1.Reset()
-	w.buf1.PutBE32(MagicIndex)
-	w.buf1.PutByte(FormatV2)
-
-	return w.write(w.buf1.Get())
-}
-
-// AddSeries adds the series one at a time along with its chunks.
-func (w *Writer) AddSeries(ref uint64, lset labels.Labels, chunks ...chunks.Meta) error {
-	if err := w.ensureStage(idxStageSeries); err != nil {
-		return err
-	}
-	if labels.Compare(lset, w.lastSeries) <= 0 {
-		return errors.Errorf("out-of-order series added with label set %q", lset)
-	}
-
-	if _, ok := w.seriesOffsets[ref]; ok {
-		return errors.Errorf("series with reference %d already added", ref)
-	}
-	// We add padding to 16 bytes to increase the addressable space we get through 4 byte
-	// series references.
-	if err := w.addPadding(16); err != nil {
-		return errors.Errorf("failed to write padding bytes: %v", err)
-	}
-
-	if w.pos%16 != 0 {
-		return errors.Errorf("series write not 16-byte aligned at %d", w.pos)
-	}
-	w.seriesOffsets[ref] = w.pos / 16
-
-	w.buf2.Reset()
-	w.buf2.PutUvarint(len(lset))
-
-	for _, l := range lset {
-		// here we have an index for the symbol file if v2, otherwise it's an offset
-		index, ok := w.symbols[l.Name]
-		if !ok {
-			return errors.Errorf("symbol entry for %q does not exist", l.Name)
-		}
-		w.buf2.PutUvarint32(index)
-
-		index, ok = w.symbols[l.Value]
-		if !ok {
-			return errors.Errorf("symbol entry for %q does not exist", l.Value)
-		}
-		w.buf2.PutUvarint32(index)
-	}
-
-	w.buf2.PutUvarint(len(chunks))
-
-	if len(chunks) > 0 {
-		c := chunks[0]
-		w.buf2.PutVarint64(c.MinTime)
-		w.buf2.PutUvarint64(uint64(c.MaxTime - c.MinTime))
-		w.buf2.PutUvarint64(c.Ref)
-		t0 := c.MaxTime
-		ref0 := int64(c.Ref)
-
-		for _, c := range chunks[1:] {
-			w.buf2.PutUvarint64(uint64(c.MinTime - t0))
-			w.buf2.PutUvarint64(uint64(c.MaxTime - c.MinTime))
-			t0 = c.MaxTime
-
-			w.buf2.PutVarint64(int64(c.Ref) - ref0)
-			ref0 = int64(c.Ref)
-		}
-	}
-
-	w.buf1.Reset()
-	w.buf1.PutUvarint(w.buf2.Len())
-
-	w.buf2.PutHash(w.crc32)
-
-	if err := w.write(w.buf1.Get(), w.buf2.Get()); err != nil {
-		return errors.Wrap(err, "write series data")
-	}
-
-	w.lastSeries = append(w.lastSeries[:0], lset...)
-
-	return nil
-}
-
-func (w *Writer) AddSymbols(sym map[string]struct{}) error {
-	if err := w.ensureStage(idxStageSymbols); err != nil {
-		return err
-	}
-	// Generate sorted list of strings we will store as reference table.
-	symbols := make([]string, 0, len(sym))
-
-	for s := range sym {
-		symbols = append(symbols, s)
-	}
-	sort.Strings(symbols)
-
-	w.buf1.Reset()
-	w.buf2.Reset()
-
-	w.buf2.PutBE32int(len(symbols))
-
-	w.symbols = make(map[string]uint32, len(symbols))
-
-	for index, s := range symbols {
-		w.symbols[s] = uint32(index)
-		w.buf2.PutUvarintStr(s)
-	}
-
-	w.buf1.PutBE32int(w.buf2.Len())
-	w.buf2.PutHash(w.crc32)
-
-	err := w.write(w.buf1.Get(), w.buf2.Get())
-	return errors.Wrap(err, "write symbols")
-}
-
-func (w *Writer) WriteLabelIndex(names []string, values []string) error {
-	if len(values)%len(names) != 0 {
-		return errors.Errorf("invalid value list length %d for %d names", len(values), len(names))
-	}
-	if err := w.ensureStage(idxStageLabelIndex); err != nil {
-		return errors.Wrap(err, "ensure stage")
-	}
-
-	valt, err := NewStringTuples(values, len(names))
-	if err != nil {
-		return err
-	}
-	sort.Sort(valt)
-
-	// Align beginning to 4 bytes for more efficient index list scans.
-	if err := w.addPadding(4); err != nil {
-		return err
-	}
-
-	w.labelIndexes = append(w.labelIndexes, labelIndexHashEntry{
-		keys:   names,
-		offset: w.pos,
-	})
-
-	w.buf2.Reset()
-	w.buf2.PutBE32int(len(names))
-	w.buf2.PutBE32int(valt.Len())
-
-	// here we have an index for the symbol file if v2, otherwise it's an offset
-	for _, v := range valt.entries {
-		index, ok := w.symbols[v]
-		if !ok {
-			return errors.Errorf("symbol entry for %q does not exist", v)
-		}
-		w.buf2.PutBE32(index)
-	}
-
-	w.buf1.Reset()
-	w.buf1.PutBE32int(w.buf2.Len())
-
-	w.buf2.PutHash(w.crc32)
-
-	err = w.write(w.buf1.Get(), w.buf2.Get())
-	return errors.Wrap(err, "write label index")
-}
-
-// writeLabelIndexesOffsetTable writes the label indices offset table.
-func (w *Writer) writeLabelIndexesOffsetTable() error {
-	w.buf2.Reset()
-	w.buf2.PutBE32int(len(w.labelIndexes))
-
-	for _, e := range w.labelIndexes {
-		w.buf2.PutUvarint(len(e.keys))
-		for _, k := range e.keys {
-			w.buf2.PutUvarintStr(k)
-		}
-		w.buf2.PutUvarint64(e.offset)
-	}
-
-	w.buf1.Reset()
-	w.buf1.PutBE32int(w.buf2.Len())
-	w.buf2.PutHash(w.crc32)
-
-	return w.write(w.buf1.Get(), w.buf2.Get())
-}
-
-// writePostingsOffsetTable writes the postings offset table.
-func (w *Writer) writePostingsOffsetTable() error {
-	w.buf2.Reset()
-	w.buf2.PutBE32int(len(w.postings))
-
-	for _, e := range w.postings {
-		w.buf2.PutUvarint(2)
-		w.buf2.PutUvarintStr(e.name)
-		w.buf2.PutUvarintStr(e.value)
-		w.buf2.PutUvarint64(e.offset)
-	}
-
-	w.buf1.Reset()
-	w.buf1.PutBE32int(w.buf2.Len())
-	w.buf2.PutHash(w.crc32)
-
-	return w.write(w.buf1.Get(), w.buf2.Get())
-}
-
-const indexTOCLen = 6*8 + 4
-
-func (w *Writer) writeTOC() error {
-	w.buf1.Reset()
-
-	w.buf1.PutBE64(w.toc.Symbols)
-	w.buf1.PutBE64(w.toc.Series)
-	w.buf1.PutBE64(w.toc.LabelIndices)
-	w.buf1.PutBE64(w.toc.LabelIndicesTable)
-	w.buf1.PutBE64(w.toc.Postings)
-	w.buf1.PutBE64(w.toc.PostingsTable)
-
-	w.buf1.PutHash(w.crc32)
-
-	return w.write(w.buf1.Get())
-}
-
-func (w *Writer) WritePostings(name, value string, it Postings) error {
-	if err := w.ensureStage(idxStagePostings); err != nil {
-		return errors.Wrap(err, "ensure stage")
-	}
-
-	// Align beginning to 4 bytes for more efficient postings list scans.
-	if err := w.addPadding(4); err != nil {
-		return err
-	}
-
-	w.postings = append(w.postings, postingsHashEntry{
-		name:   name,
-		value:  value,
-		offset: w.pos,
-	})
-
-	// Order of the references in the postings list does not imply order
-	// of the series references within the persisted block they are mapped to.
-	// We have to sort the new references again.
-	refs := w.uint32s[:0]
-
-	for it.Next() {
-		offset, ok := w.seriesOffsets[it.At()]
-		if !ok {
-			return errors.Errorf("%p series for reference %d not found", w, it.At())
-		}
-		if offset > (1<<32)-1 {
-			return errors.Errorf("series offset %d exceeds 4 bytes", offset)
-		}
-		refs = append(refs, uint32(offset))
-	}
-	if err := it.Err(); err != nil {
-		return err
-	}
-	sort.Sort(uint32slice(refs))
-
-	w.buf2.Reset()
-	w.buf2.PutBE32int(len(refs))
-
-	for _, r := range refs {
-		w.buf2.PutBE32(r)
-	}
-	w.uint32s = refs
-
-	w.buf1.Reset()
-	w.buf1.PutBE32int(w.buf2.Len())
-
-	w.buf2.PutHash(w.crc32)
-
-	err := w.write(w.buf1.Get(), w.buf2.Get())
-	return errors.Wrap(err, "write postings")
-}
-
-type uint32slice []uint32
-
-func (s uint32slice) Len() int           { return len(s) }
-func (s uint32slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-func (s uint32slice) Less(i, j int) bool { return s[i] < s[j] }
-
-type labelIndexHashEntry struct {
-	keys   []string
-	offset uint64
-}
-
-type postingsHashEntry struct {
-	name, value string
-	offset      uint64
-}
-
-func (w *Writer) Close() error {
-	if err := w.ensureStage(idxStageDone); err != nil {
-		return err
-	}
-	if err := w.fbuf.Flush(); err != nil {
-		return err
-	}
-	if err := w.f.Sync(); err != nil {
-		return err
-	}
-	return w.f.Close()
-}
-
-// StringTuples provides access to a sorted list of string tuples.
-type StringTuples interface {
-	// Total number of tuples in the list.
-	Len() int
-	// At returns the tuple at position i.
-	At(i int) ([]string, error)
-}
-
-type Reader struct {
-	b ByteSlice
-
-	// Close that releases the underlying resources of the byte slice.
-	c io.Closer
-
-	// Cached hashmaps of section offsets.
-	labels map[string]uint64
-	// LabelName to LabelValue to offset map.
-	postings map[string]map[string]uint64
-	// Cache of read symbols. Strings that are returned when reading from the
-	// block are always backed by true strings held in here rather than
-	// strings that are backed by byte slices from the mmap'd index file. This
-	// prevents memory faults when applications work with read symbols after
-	// the block has been unmapped. The older format has sparse indexes so a map
-	// must be used, but the new format is not so we can use a slice.
-	symbolsV1        map[uint32]string
-	symbolsV2        []string
-	symbolsTableSize uint64
-
-	dec *Decoder
-
-	version int
-}
-
-// ByteSlice abstracts a byte slice.
-type ByteSlice interface {
-	Len() int
-	Range(start, end int) []byte
-}
-
-type realByteSlice []byte
-
-func (b realByteSlice) Len() int {
-	return len(b)
-}
-
-func (b realByteSlice) Range(start, end int) []byte {
-	return b[start:end]
-}
-
-func (b realByteSlice) Sub(start, end int) ByteSlice {
-	return b[start:end]
-}
-
-// NewReader returns a new index reader on the given byte slice. It automatically
-// handles different format versions.
-func NewReader(b ByteSlice) (*Reader, error) {
-	return newReader(b, ioutil.NopCloser(nil))
-}
-
-// NewFileReader returns a new index reader against the given index file.
-func NewFileReader(path string) (*Reader, error) {
-	f, err := fileutil.OpenMmapFile(path)
-	if err != nil {
-		return nil, err
-	}
-	r, err := newReader(realByteSlice(f.Bytes()), f)
-	if err != nil {
-		var merr tsdb_errors.MultiError
-		merr.Add(err)
-		merr.Add(f.Close())
-		return nil, merr
-	}
-
-	return r, nil
-}
-
-func newReader(b ByteSlice, c io.Closer) (*Reader, error) {
-	r := &Reader{
-		b:        b,
-		c:        c,
-		labels:   map[string]uint64{},
-		postings: map[string]map[string]uint64{},
-	}
-
-	// Verify header.
-	if r.b.Len() < HeaderLen {
-		return nil, errors.Wrap(encoding.ErrInvalidSize, "index header")
-	}
-	if m := binary.BigEndian.Uint32(r.b.Range(0, 4)); m != MagicIndex {
-		return nil, errors.Errorf("invalid magic number %x", m)
-	}
-	r.version = int(r.b.Range(4, 5)[0])
-
-	if r.version != FormatV1 && r.version != FormatV2 {
-		return nil, errors.Errorf("unknown index file version %d", r.version)
-	}
-
-	toc, err := NewTOCFromByteSlice(b)
-	if err != nil {
-		return nil, errors.Wrap(err, "read TOC")
-	}
-
-	r.symbolsV2, r.symbolsV1, err = ReadSymbols(r.b, r.version, int(toc.Symbols))
-	if err != nil {
-		return nil, errors.Wrap(err, "read symbols")
-	}
-
-	// Use the strings already allocated by symbols, rather than
-	// re-allocating them again below.
-	// Additionally, calculate symbolsTableSize.
-	allocatedSymbols := make(map[string]string, len(r.symbolsV1)+len(r.symbolsV2))
-	for _, s := range r.symbolsV1 {
-		r.symbolsTableSize += uint64(len(s) + 8)
-		allocatedSymbols[s] = s
-	}
-	for _, s := range r.symbolsV2 {
-		r.symbolsTableSize += uint64(len(s) + 8)
-		allocatedSymbols[s] = s
-	}
-
-	if err := ReadOffsetTable(r.b, toc.LabelIndicesTable, func(key []string, off uint64) error {
-		if len(key) != 1 {
-			return errors.Errorf("unexpected key length for label indices table %d", len(key))
-		}
-
-		r.labels[allocatedSymbols[key[0]]] = off
-		return nil
-	}); err != nil {
-		return nil, errors.Wrap(err, "read label index table")
-	}
-
-	r.postings[""] = map[string]uint64{}
-	if err := ReadOffsetTable(r.b, toc.PostingsTable, func(key []string, off uint64) error {
-		if len(key) != 2 {
-			return errors.Errorf("unexpected key length for posting table %d", len(key))
-		}
-		if _, ok := r.postings[key[0]]; !ok {
-			r.postings[allocatedSymbols[key[0]]] = map[string]uint64{}
-		}
-		r.postings[key[0]][allocatedSymbols[key[1]]] = off
-		return nil
-	}); err != nil {
-		return nil, errors.Wrap(err, "read postings table")
-	}
-
-	r.dec = &Decoder{LookupSymbol: r.lookupSymbol}
-
-	return r, nil
-}
-
-// Version returns the file format version of the underlying index.
-func (r *Reader) Version() int {
-	return r.version
-}
-
-// Range marks a byte range.
-type Range struct {
-	Start, End int64
-}
-
-// PostingsRanges returns a new map of byte range in the underlying index file
-// for all postings lists.
-func (r *Reader) PostingsRanges() (map[labels.Label]Range, error) {
-	m := map[labels.Label]Range{}
-
-	for k, e := range r.postings {
-		for v, start := range e {
-			d := encoding.NewDecbufAt(r.b, int(start), castagnoliTable)
-			if d.Err() != nil {
-				return nil, d.Err()
-			}
-			m[labels.Label{Name: k, Value: v}] = Range{
-				Start: int64(start) + 4,
-				End:   int64(start) + 4 + int64(d.Len()),
-			}
-		}
-	}
-	return m, nil
-}
-
-// ReadSymbols reads the symbol table fully into memory and allocates proper strings for them.
-// Strings backed by the mmap'd memory would cause memory faults if applications keep using them
-// after the reader is closed.
-func ReadSymbols(bs ByteSlice, version int, off int) ([]string, map[uint32]string, error) {
-	if off == 0 {
-		return nil, nil, nil
-	}
-	d := encoding.NewDecbufAt(bs, off, castagnoliTable)
-
-	var (
-		origLen     = d.Len()
-		cnt         = d.Be32int()
-		basePos     = uint32(off) + 4
-		nextPos     = basePos + uint32(origLen-d.Len())
-		symbolSlice []string
-		symbols     = map[uint32]string{}
-	)
-	if version == FormatV2 {
-		symbolSlice = make([]string, 0, cnt)
-	}
-
-	for d.Err() == nil && d.Len() > 0 && cnt > 0 {
-		s := d.UvarintStr()
-
-		if version == FormatV2 {
-			symbolSlice = append(symbolSlice, s)
-		} else {
-			symbols[nextPos] = s
-			nextPos = basePos + uint32(origLen-d.Len())
-		}
-		cnt--
-	}
-	return symbolSlice, symbols, errors.Wrap(d.Err(), "read symbols")
-}
-
-// ReadOffsetTable reads an offset table and at the given position calls f for each
-// found entry. If f returns an error it stops decoding and returns the received error.
-func ReadOffsetTable(bs ByteSlice, off uint64, f func([]string, uint64) error) error {
-	d := encoding.NewDecbufAt(bs, int(off), castagnoliTable)
-	cnt := d.Be32()
-
-	// The Postings offset table takes only 2 keys per entry (name and value of label),
-	// and the LabelIndices offset table takes only 1 key per entry (a label name).
-	// Hence setting the size to max of both, i.e. 2.
-	keys := make([]string, 0, 2)
-	for d.Err() == nil && d.Len() > 0 && cnt > 0 {
-		keyCount := d.Uvarint()
-		keys = keys[:0]
-
-		for i := 0; i < keyCount; i++ {
-			keys = append(keys, d.UvarintStr())
-		}
-		o := d.Uvarint64()
-		if d.Err() != nil {
-			break
-		}
-		if err := f(keys, o); err != nil {
-			return err
-		}
-		cnt--
-	}
-	return d.Err()
-}
-
-// Close the reader and its underlying resources.
-func (r *Reader) Close() error {
-	return r.c.Close()
-}
-
-func (r *Reader) lookupSymbol(o uint32) (string, error) {
-	if int(o) < len(r.symbolsV2) {
-		return r.symbolsV2[o], nil
-	}
-	s, ok := r.symbolsV1[o]
-	if !ok {
-		return "", errors.Errorf("unknown symbol offset %d", o)
-	}
-	return s, nil
-}
-
-// Symbols returns a set of symbols that exist within the index.
-func (r *Reader) Symbols() (map[string]struct{}, error) {
-	res := make(map[string]struct{}, len(r.symbolsV1)+len(r.symbolsV2))
-
-	for _, s := range r.symbolsV1 {
-		res[s] = struct{}{}
-	}
-	for _, s := range r.symbolsV2 {
-		res[s] = struct{}{}
-	}
-	return res, nil
-}
-
-// SymbolTableSize returns the symbol table size in bytes.
-func (r *Reader) SymbolTableSize() uint64 {
-	return r.symbolsTableSize
-}
-
-// LabelValues returns value tuples that exist for the given label name tuples.
-func (r *Reader) LabelValues(names ...string) (StringTuples, error) {
-
-	key := strings.Join(names, labelNameSeperator)
-	off, ok := r.labels[key]
-	if !ok {
-		// XXX(fabxc): hot fix. Should return a partial data error and handle cases
-		// where the entire block has no data gracefully.
-		return emptyStringTuples{}, nil
-		//return nil, fmt.Errorf("label index doesn't exist")
-	}
-
-	d := encoding.NewDecbufAt(r.b, int(off), castagnoliTable)
-
-	nc := d.Be32int()
-	d.Be32() // consume unused value entry count.
-
-	if d.Err() != nil {
-		return nil, errors.Wrap(d.Err(), "read label value index")
-	}
-	st := &serializedStringTuples{
-		idsCount: nc,
-		idsBytes: d.Get(),
-		lookup:   r.lookupSymbol,
-	}
-	return st, nil
-}
-
-type emptyStringTuples struct{}
-
-func (emptyStringTuples) At(i int) ([]string, error) { return nil, nil }
-func (emptyStringTuples) Len() int                   { return 0 }
-
-// LabelIndices returns a slice of label names for which labels or label tuples value indices exist.
-// NOTE: This is deprecated. Use `LabelNames()` instead.
-func (r *Reader) LabelIndices() ([][]string, error) {
-	var res [][]string
-	for s := range r.labels {
-		res = append(res, strings.Split(s, labelNameSeperator))
-	}
-	return res, nil
-}
-
-// Series reads the series with the given ID and writes its labels and chunks into lbls and chks.
-func (r *Reader) Series(id uint64, lbls *labels.Labels, chks *[]chunks.Meta) error {
-	offset := id
-	// In version 2 series IDs are no longer exact references but series are 16-byte padded
-	// and the ID is the multiple of 16 of the actual position.
-	if r.version == FormatV2 {
-		offset = id * 16
-	}
-	d := encoding.NewDecbufUvarintAt(r.b, int(offset), castagnoliTable)
-	if d.Err() != nil {
-		return d.Err()
-	}
-	return errors.Wrap(r.dec.Series(d.Get(), lbls, chks), "read series")
-}
-
-// Postings returns a postings list for the given label pair.
-func (r *Reader) Postings(name, value string) (Postings, error) {
-	e, ok := r.postings[name]
-	if !ok {
-		return EmptyPostings(), nil
-	}
-	off, ok := e[value]
-	if !ok {
-		return EmptyPostings(), nil
-	}
-	d := encoding.NewDecbufAt(r.b, int(off), castagnoliTable)
-	if d.Err() != nil {
-		return nil, errors.Wrap(d.Err(), "get postings entry")
-	}
-	_, p, err := r.dec.Postings(d.Get())
-	if err != nil {
-		return nil, errors.Wrap(err, "decode postings")
-	}
-	return p, nil
-}
-
-// SortedPostings returns the given postings list reordered so that the backing series
-// are sorted.
-func (r *Reader) SortedPostings(p Postings) Postings {
-	return p
-}
-
-// Size returns the size of an index file.
-func (r *Reader) Size() int64 {
-	return int64(r.b.Len())
-}
-
-// LabelNames returns all the unique label names present in the index.
-func (r *Reader) LabelNames() ([]string, error) {
-	labelNamesMap := make(map[string]struct{}, len(r.labels))
-	for key := range r.labels {
-		// 'key' contains the label names concatenated with the
-		// delimiter 'labelNameSeperator'.
-		names := strings.Split(key, labelNameSeperator)
-		for _, name := range names {
-			if name == allPostingsKey.Name {
-				// This is not from any metric.
-				// It is basically an empty label name.
-				continue
-			}
-			labelNamesMap[name] = struct{}{}
-		}
-	}
-	labelNames := make([]string, 0, len(labelNamesMap))
-	for name := range labelNamesMap {
-		labelNames = append(labelNames, name)
-	}
-	sort.Strings(labelNames)
-	return labelNames, nil
-}
-
-type stringTuples struct {
-	length  int      // tuple length
-	entries []string // flattened tuple entries
-	swapBuf []string
-}
-
-func NewStringTuples(entries []string, length int) (*stringTuples, error) {
-	if len(entries)%length != 0 {
-		return nil, errors.Wrap(encoding.ErrInvalidSize, "string tuple list")
-	}
-	return &stringTuples{
-		entries: entries,
-		length:  length,
-	}, nil
-}
-
-func (t *stringTuples) Len() int                   { return len(t.entries) / t.length }
-func (t *stringTuples) At(i int) ([]string, error) { return t.entries[i : i+t.length], nil }
-
-func (t *stringTuples) Swap(i, j int) {
-	if t.swapBuf == nil {
-		t.swapBuf = make([]string, t.length)
-	}
-	copy(t.swapBuf, t.entries[i:i+t.length])
-	for k := 0; k < t.length; k++ {
-		t.entries[i+k] = t.entries[j+k]
-		t.entries[j+k] = t.swapBuf[k]
-	}
-}
-
-func (t *stringTuples) Less(i, j int) bool {
-	for k := 0; k < t.length; k++ {
-		d := strings.Compare(t.entries[i+k], t.entries[j+k])
-
-		if d < 0 {
-			return true
-		}
-		if d > 0 {
-			return false
-		}
-	}
-	return false
-}
-
-type serializedStringTuples struct {
-	idsCount int
-	idsBytes []byte // bytes containing the ids pointing to the string in the lookup table.
-	lookup   func(uint32) (string, error)
-}
-
-func (t *serializedStringTuples) Len() int {
-	return len(t.idsBytes) / (4 * t.idsCount)
-}
-
-func (t *serializedStringTuples) At(i int) ([]string, error) {
-	if len(t.idsBytes) < (i+t.idsCount)*4 {
-		return nil, encoding.ErrInvalidSize
-	}
-	res := make([]string, 0, t.idsCount)
-
-	for k := 0; k < t.idsCount; k++ {
-		offset := binary.BigEndian.Uint32(t.idsBytes[(i+k)*4:])
-
-		s, err := t.lookup(offset)
-		if err != nil {
-			return nil, errors.Wrap(err, "symbol lookup")
-		}
-		res = append(res, s)
-	}
-
-	return res, nil
-}
-
-// Decoder provides decoding methods for the v1 and v2 index file format.
-//
-// It currently does not contain decoding methods for all entry types but can be extended
-// by them if there's demand.
-type Decoder struct {
-	LookupSymbol func(uint32) (string, error)
-}
-
-// Postings returns a postings list for b and its number of elements.
-func (dec *Decoder) Postings(b []byte) (int, Postings, error) {
-	d := encoding.Decbuf{B: b}
-	n := d.Be32int()
-	l := d.Get()
-	return n, newBigEndianPostings(l), d.Err()
-}
-
-// Series decodes a series entry from the given byte slice into lset and chks.
-func (dec *Decoder) Series(b []byte, lbls *labels.Labels, chks *[]chunks.Meta) error {
-	*lbls = (*lbls)[:0]
-	*chks = (*chks)[:0]
-
-	d := encoding.Decbuf{B: b}
-
-	k := d.Uvarint()
-
-	for i := 0; i < k; i++ {
-		lno := uint32(d.Uvarint())
-		lvo := uint32(d.Uvarint())
-
-		if d.Err() != nil {
-			return errors.Wrap(d.Err(), "read series label offsets")
-		}
-
-		ln, err := dec.LookupSymbol(lno)
-		if err != nil {
-			return errors.Wrap(err, "lookup label name")
-		}
-		lv, err := dec.LookupSymbol(lvo)
-		if err != nil {
-			return errors.Wrap(err, "lookup label value")
-		}
-
-		*lbls = append(*lbls, labels.Label{Name: ln, Value: lv})
-	}
-
-	// Read the chunks meta data.
-	k = d.Uvarint()
-
-	if k == 0 {
-		return nil
-	}
-
-	t0 := d.Varint64()
-	maxt := int64(d.Uvarint64()) + t0
-	ref0 := int64(d.Uvarint64())
-
-	*chks = append(*chks, chunks.Meta{
-		Ref:     uint64(ref0),
-		MinTime: t0,
-		MaxTime: maxt,
-	})
-	t0 = maxt
-
-	for i := 1; i < k; i++ {
-		mint := int64(d.Uvarint64()) + t0
-		maxt := int64(d.Uvarint64()) + mint
-
-		ref0 += d.Varint64()
-		t0 = maxt
-
-		if d.Err() != nil {
-			return errors.Wrapf(d.Err(), "read meta for chunk %d", i)
-		}
-
-		*chks = append(*chks, chunks.Meta{
-			Ref:     uint64(ref0),
-			MinTime: mint,
-			MaxTime: maxt,
-		})
-	}
-	return d.Err()
-}
diff --git a/vendor/github.com/prometheus/tsdb/index/postings.go b/vendor/github.com/prometheus/tsdb/index/postings.go
deleted file mode 100644
index cef2d886e0..0000000000
--- a/vendor/github.com/prometheus/tsdb/index/postings.go
+++ /dev/null
@@ -1,691 +0,0 @@
-// Copyright 2017 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.
-
-package index
-
-import (
-	"container/heap"
-	"encoding/binary"
-	"runtime"
-	"sort"
-	"strings"
-	"sync"
-
-	"github.com/prometheus/tsdb/labels"
-)
-
-var allPostingsKey = labels.Label{}
-
-// AllPostingsKey returns the label key that is used to store the postings list of all existing IDs.
-func AllPostingsKey() (name, value string) {
-	return allPostingsKey.Name, allPostingsKey.Value
-}
-
-// MemPostings holds postings list for series ID per label pair. They may be written
-// to out of order.
-// ensureOrder() must be called once before any reads are done. This allows for quick
-// unordered batch fills on startup.
-type MemPostings struct {
-	mtx     sync.RWMutex
-	m       map[string]map[string][]uint64
-	ordered bool
-}
-
-// NewMemPostings returns a memPostings that's ready for reads and writes.
-func NewMemPostings() *MemPostings {
-	return &MemPostings{
-		m:       make(map[string]map[string][]uint64, 512),
-		ordered: true,
-	}
-}
-
-// NewUnorderedMemPostings returns a memPostings that is not safe to be read from
-// until ensureOrder was called once.
-func NewUnorderedMemPostings() *MemPostings {
-	return &MemPostings{
-		m:       make(map[string]map[string][]uint64, 512),
-		ordered: false,
-	}
-}
-
-// SortedKeys returns a list of sorted label keys of the postings.
-func (p *MemPostings) SortedKeys() []labels.Label {
-	p.mtx.RLock()
-	keys := make([]labels.Label, 0, len(p.m))
-
-	for n, e := range p.m {
-		for v := range e {
-			keys = append(keys, labels.Label{Name: n, Value: v})
-		}
-	}
-	p.mtx.RUnlock()
-
-	sort.Slice(keys, func(i, j int) bool {
-		if d := strings.Compare(keys[i].Name, keys[j].Name); d != 0 {
-			return d < 0
-		}
-		return keys[i].Value < keys[j].Value
-	})
-	return keys
-}
-
-// Get returns a postings list for the given label pair.
-func (p *MemPostings) Get(name, value string) Postings {
-	var lp []uint64
-	p.mtx.RLock()
-	l := p.m[name]
-	if l != nil {
-		lp = l[value]
-	}
-	p.mtx.RUnlock()
-
-	if lp == nil {
-		return EmptyPostings()
-	}
-	return newListPostings(lp...)
-}
-
-// All returns a postings list over all documents ever added.
-func (p *MemPostings) All() Postings {
-	return p.Get(AllPostingsKey())
-}
-
-// EnsureOrder ensures that all postings lists are sorted. After it returns all further
-// calls to add and addFor will insert new IDs in a sorted manner.
-func (p *MemPostings) EnsureOrder() {
-	p.mtx.Lock()
-	defer p.mtx.Unlock()
-
-	if p.ordered {
-		return
-	}
-
-	n := runtime.GOMAXPROCS(0)
-	workc := make(chan []uint64)
-
-	var wg sync.WaitGroup
-	wg.Add(n)
-
-	for i := 0; i < n; i++ {
-		go func() {
-			for l := range workc {
-				sort.Slice(l, func(i, j int) bool { return l[i] < l[j] })
-			}
-			wg.Done()
-		}()
-	}
-
-	for _, e := range p.m {
-		for _, l := range e {
-			workc <- l
-		}
-	}
-	close(workc)
-	wg.Wait()
-
-	p.ordered = true
-}
-
-// Delete removes all ids in the given map from the postings lists.
-func (p *MemPostings) Delete(deleted map[uint64]struct{}) {
-	var keys, vals []string
-
-	// Collect all keys relevant for deletion once. New keys added afterwards
-	// can by definition not be affected by any of the given deletes.
-	p.mtx.RLock()
-	for n := range p.m {
-		keys = append(keys, n)
-	}
-	p.mtx.RUnlock()
-
-	for _, n := range keys {
-		p.mtx.RLock()
-		vals = vals[:0]
-		for v := range p.m[n] {
-			vals = append(vals, v)
-		}
-		p.mtx.RUnlock()
-
-		// For each posting we first analyse whether the postings list is affected by the deletes.
-		// If yes, we actually reallocate a new postings list.
-		for _, l := range vals {
-			// Only lock for processing one postings list so we don't block reads for too long.
-			p.mtx.Lock()
-
-			found := false
-			for _, id := range p.m[n][l] {
-				if _, ok := deleted[id]; ok {
-					found = true
-					break
-				}
-			}
-			if !found {
-				p.mtx.Unlock()
-				continue
-			}
-			repl := make([]uint64, 0, len(p.m[n][l]))
-
-			for _, id := range p.m[n][l] {
-				if _, ok := deleted[id]; !ok {
-					repl = append(repl, id)
-				}
-			}
-			if len(repl) > 0 {
-				p.m[n][l] = repl
-			} else {
-				delete(p.m[n], l)
-			}
-			p.mtx.Unlock()
-		}
-		p.mtx.Lock()
-		if len(p.m[n]) == 0 {
-			delete(p.m, n)
-		}
-		p.mtx.Unlock()
-	}
-}
-
-// Iter calls f for each postings list. It aborts if f returns an error and returns it.
-func (p *MemPostings) Iter(f func(labels.Label, Postings) error) error {
-	p.mtx.RLock()
-	defer p.mtx.RUnlock()
-
-	for n, e := range p.m {
-		for v, p := range e {
-			if err := f(labels.Label{Name: n, Value: v}, newListPostings(p...)); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// Add a label set to the postings index.
-func (p *MemPostings) Add(id uint64, lset labels.Labels) {
-	p.mtx.Lock()
-
-	for _, l := range lset {
-		p.addFor(id, l)
-	}
-	p.addFor(id, allPostingsKey)
-
-	p.mtx.Unlock()
-}
-
-func (p *MemPostings) addFor(id uint64, l labels.Label) {
-	nm, ok := p.m[l.Name]
-	if !ok {
-		nm = map[string][]uint64{}
-		p.m[l.Name] = nm
-	}
-	list := append(nm[l.Value], id)
-	nm[l.Value] = list
-
-	if !p.ordered {
-		return
-	}
-	// There is no guarantee that no higher ID was inserted before as they may
-	// be generated independently before adding them to postings.
-	// We repair order violations on insert. The invariant is that the first n-1
-	// items in the list are already sorted.
-	for i := len(list) - 1; i >= 1; i-- {
-		if list[i] >= list[i-1] {
-			break
-		}
-		list[i], list[i-1] = list[i-1], list[i]
-	}
-}
-
-// ExpandPostings returns the postings expanded as a slice.
-func ExpandPostings(p Postings) (res []uint64, err error) {
-	for p.Next() {
-		res = append(res, p.At())
-	}
-	return res, p.Err()
-}
-
-// Postings provides iterative access over a postings list.
-type Postings interface {
-	// Next advances the iterator and returns true if another value was found.
-	Next() bool
-
-	// Seek advances the iterator to value v or greater and returns
-	// true if a value was found.
-	Seek(v uint64) bool
-
-	// At returns the value at the current iterator position.
-	At() uint64
-
-	// Err returns the last error of the iterator.
-	Err() error
-}
-
-// errPostings is an empty iterator that always errors.
-type errPostings struct {
-	err error
-}
-
-func (e errPostings) Next() bool       { return false }
-func (e errPostings) Seek(uint64) bool { return false }
-func (e errPostings) At() uint64       { return 0 }
-func (e errPostings) Err() error       { return e.err }
-
-var emptyPostings = errPostings{}
-
-// EmptyPostings returns a postings list that's always empty.
-// NOTE: Returning EmptyPostings sentinel when index.Postings struct has no postings is recommended.
-// It triggers optimized flow in other functions like Intersect, Without etc.
-func EmptyPostings() Postings {
-	return emptyPostings
-}
-
-// ErrPostings returns new postings that immediately error.
-func ErrPostings(err error) Postings {
-	return errPostings{err}
-}
-
-// Intersect returns a new postings list over the intersection of the
-// input postings.
-func Intersect(its ...Postings) Postings {
-	if len(its) == 0 {
-		return EmptyPostings()
-	}
-	if len(its) == 1 {
-		return its[0]
-	}
-	for _, p := range its {
-		if p == EmptyPostings() {
-			return EmptyPostings()
-		}
-	}
-
-	return newIntersectPostings(its...)
-}
-
-type intersectPostings struct {
-	arr []Postings
-	cur uint64
-}
-
-func newIntersectPostings(its ...Postings) *intersectPostings {
-	return &intersectPostings{arr: its}
-}
-
-func (it *intersectPostings) At() uint64 {
-	return it.cur
-}
-
-func (it *intersectPostings) doNext() bool {
-Loop:
-	for {
-		for _, p := range it.arr {
-			if !p.Seek(it.cur) {
-				return false
-			}
-			if p.At() > it.cur {
-				it.cur = p.At()
-				continue Loop
-			}
-		}
-		return true
-	}
-}
-
-func (it *intersectPostings) Next() bool {
-	for _, p := range it.arr {
-		if !p.Next() {
-			return false
-		}
-		if p.At() > it.cur {
-			it.cur = p.At()
-		}
-	}
-	return it.doNext()
-}
-
-func (it *intersectPostings) Seek(id uint64) bool {
-	it.cur = id
-	return it.doNext()
-}
-
-func (it *intersectPostings) Err() error {
-	for _, p := range it.arr {
-		if p.Err() != nil {
-			return p.Err()
-		}
-	}
-	return nil
-}
-
-// Merge returns a new iterator over the union of the input iterators.
-func Merge(its ...Postings) Postings {
-	if len(its) == 0 {
-		return EmptyPostings()
-	}
-	if len(its) == 1 {
-		return its[0]
-	}
-
-	p, ok := newMergedPostings(its)
-	if !ok {
-		return EmptyPostings()
-	}
-	return p
-}
-
-type postingsHeap []Postings
-
-func (h postingsHeap) Len() int           { return len(h) }
-func (h postingsHeap) Less(i, j int) bool { return h[i].At() < h[j].At() }
-func (h *postingsHeap) Swap(i, j int)     { (*h)[i], (*h)[j] = (*h)[j], (*h)[i] }
-
-func (h *postingsHeap) Push(x interface{}) {
-	*h = append(*h, x.(Postings))
-}
-
-func (h *postingsHeap) Pop() interface{} {
-	old := *h
-	n := len(old)
-	x := old[n-1]
-	*h = old[0 : n-1]
-	return x
-}
-
-type mergedPostings struct {
-	h          postingsHeap
-	initilized bool
-	cur        uint64
-	err        error
-}
-
-func newMergedPostings(p []Postings) (m *mergedPostings, nonEmpty bool) {
-	ph := make(postingsHeap, 0, len(p))
-
-	for _, it := range p {
-		// NOTE: mergedPostings struct requires the user to issue an initial Next.
-		if it.Next() {
-			ph = append(ph, it)
-		} else {
-			if it.Err() != nil {
-				return &mergedPostings{err: it.Err()}, true
-			}
-		}
-	}
-
-	if len(ph) == 0 {
-		return nil, false
-	}
-	return &mergedPostings{h: ph}, true
-}
-
-func (it *mergedPostings) Next() bool {
-	if it.h.Len() == 0 || it.err != nil {
-		return false
-	}
-
-	// The user must issue an initial Next.
-	if !it.initilized {
-		heap.Init(&it.h)
-		it.cur = it.h[0].At()
-		it.initilized = true
-		return true
-	}
-
-	for {
-		cur := it.h[0]
-		if !cur.Next() {
-			heap.Pop(&it.h)
-			if cur.Err() != nil {
-				it.err = cur.Err()
-				return false
-			}
-			if it.h.Len() == 0 {
-				return false
-			}
-		} else {
-			// Value of top of heap has changed, re-heapify.
-			heap.Fix(&it.h, 0)
-		}
-
-		if it.h[0].At() != it.cur {
-			it.cur = it.h[0].At()
-			return true
-		}
-	}
-}
-
-func (it *mergedPostings) Seek(id uint64) bool {
-	if it.h.Len() == 0 || it.err != nil {
-		return false
-	}
-	if !it.initilized {
-		if !it.Next() {
-			return false
-		}
-	}
-	for it.cur < id {
-		cur := it.h[0]
-		if !cur.Seek(id) {
-			heap.Pop(&it.h)
-			if cur.Err() != nil {
-				it.err = cur.Err()
-				return false
-			}
-			if it.h.Len() == 0 {
-				return false
-			}
-		} else {
-			// Value of top of heap has changed, re-heapify.
-			heap.Fix(&it.h, 0)
-		}
-
-		it.cur = it.h[0].At()
-	}
-	return true
-}
-
-func (it mergedPostings) At() uint64 {
-	return it.cur
-}
-
-func (it mergedPostings) Err() error {
-	return it.err
-}
-
-// Without returns a new postings list that contains all elements from the full list that
-// are not in the drop list.
-func Without(full, drop Postings) Postings {
-	if full == EmptyPostings() {
-		return EmptyPostings()
-	}
-
-	if drop == EmptyPostings() {
-		return full
-	}
-	return newRemovedPostings(full, drop)
-}
-
-type removedPostings struct {
-	full, remove Postings
-
-	cur uint64
-
-	initialized bool
-	fok, rok    bool
-}
-
-func newRemovedPostings(full, remove Postings) *removedPostings {
-	return &removedPostings{
-		full:   full,
-		remove: remove,
-	}
-}
-
-func (rp *removedPostings) At() uint64 {
-	return rp.cur
-}
-
-func (rp *removedPostings) Next() bool {
-	if !rp.initialized {
-		rp.fok = rp.full.Next()
-		rp.rok = rp.remove.Next()
-		rp.initialized = true
-	}
-	for {
-		if !rp.fok {
-			return false
-		}
-
-		if !rp.rok {
-			rp.cur = rp.full.At()
-			rp.fok = rp.full.Next()
-			return true
-		}
-
-		fcur, rcur := rp.full.At(), rp.remove.At()
-		if fcur < rcur {
-			rp.cur = fcur
-			rp.fok = rp.full.Next()
-
-			return true
-		} else if rcur < fcur {
-			// Forward the remove postings to the right position.
-			rp.rok = rp.remove.Seek(fcur)
-		} else {
-			// Skip the current posting.
-			rp.fok = rp.full.Next()
-		}
-	}
-}
-
-func (rp *removedPostings) Seek(id uint64) bool {
-	if rp.cur >= id {
-		return true
-	}
-
-	rp.fok = rp.full.Seek(id)
-	rp.rok = rp.remove.Seek(id)
-	rp.initialized = true
-
-	return rp.Next()
-}
-
-func (rp *removedPostings) Err() error {
-	if rp.full.Err() != nil {
-		return rp.full.Err()
-	}
-
-	return rp.remove.Err()
-}
-
-// ListPostings implements the Postings interface over a plain list.
-type ListPostings struct {
-	list []uint64
-	cur  uint64
-}
-
-func NewListPostings(list []uint64) Postings {
-	return newListPostings(list...)
-}
-
-func newListPostings(list ...uint64) *ListPostings {
-	return &ListPostings{list: list}
-}
-
-func (it *ListPostings) At() uint64 {
-	return it.cur
-}
-
-func (it *ListPostings) Next() bool {
-	if len(it.list) > 0 {
-		it.cur = it.list[0]
-		it.list = it.list[1:]
-		return true
-	}
-	it.cur = 0
-	return false
-}
-
-func (it *ListPostings) Seek(x uint64) bool {
-	// If the current value satisfies, then return.
-	if it.cur >= x {
-		return true
-	}
-	if len(it.list) == 0 {
-		return false
-	}
-
-	// Do binary search between current position and end.
-	i := sort.Search(len(it.list), func(i int) bool {
-		return it.list[i] >= x
-	})
-	if i < len(it.list) {
-		it.cur = it.list[i]
-		it.list = it.list[i+1:]
-		return true
-	}
-	it.list = nil
-	return false
-}
-
-func (it *ListPostings) Err() error {
-	return nil
-}
-
-// bigEndianPostings implements the Postings interface over a byte stream of
-// big endian numbers.
-type bigEndianPostings struct {
-	list []byte
-	cur  uint32
-}
-
-func newBigEndianPostings(list []byte) *bigEndianPostings {
-	return &bigEndianPostings{list: list}
-}
-
-func (it *bigEndianPostings) At() uint64 {
-	return uint64(it.cur)
-}
-
-func (it *bigEndianPostings) Next() bool {
-	if len(it.list) >= 4 {
-		it.cur = binary.BigEndian.Uint32(it.list)
-		it.list = it.list[4:]
-		return true
-	}
-	return false
-}
-
-func (it *bigEndianPostings) Seek(x uint64) bool {
-	if uint64(it.cur) >= x {
-		return true
-	}
-
-	num := len(it.list) / 4
-	// Do binary search between current position and end.
-	i := sort.Search(num, func(i int) bool {
-		return binary.BigEndian.Uint32(it.list[i*4:]) >= uint32(x)
-	})
-	if i < num {
-		j := i * 4
-		it.cur = binary.BigEndian.Uint32(it.list[j:])
-		it.list = it.list[j+4:]
-		return true
-	}
-	it.list = nil
-	return false
-}
-
-func (it *bigEndianPostings) Err() error {
-	return nil
-}
diff --git a/vendor/github.com/prometheus/tsdb/labels/labels.go b/vendor/github.com/prometheus/tsdb/labels/labels.go
deleted file mode 100644
index aab8e42be9..0000000000
--- a/vendor/github.com/prometheus/tsdb/labels/labels.go
+++ /dev/null
@@ -1,233 +0,0 @@
-// Copyright 2017 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.
-
-package labels
-
-import (
-	"bufio"
-	"bytes"
-	"os"
-	"sort"
-	"strconv"
-	"strings"
-
-	"github.com/cespare/xxhash"
-	"github.com/pkg/errors"
-)
-
-const sep = '\xff'
-
-// Label is a key/value pair of strings.
-type Label struct {
-	Name, Value string
-}
-
-// Labels is a sorted set of labels. Order has to be guaranteed upon
-// instantiation.
-type Labels []Label
-
-func (ls Labels) Len() int           { return len(ls) }
-func (ls Labels) Swap(i, j int)      { ls[i], ls[j] = ls[j], ls[i] }
-func (ls Labels) Less(i, j int) bool { return ls[i].Name < ls[j].Name }
-
-func (ls Labels) String() string {
-	var b bytes.Buffer
-
-	b.WriteByte('{')
-	for i, l := range ls {
-		if i > 0 {
-			b.WriteByte(',')
-		}
-		b.WriteString(l.Name)
-		b.WriteByte('=')
-		b.WriteString(strconv.Quote(l.Value))
-	}
-	b.WriteByte('}')
-
-	return b.String()
-}
-
-// Hash returns a hash value for the label set.
-func (ls Labels) Hash() uint64 {
-	b := make([]byte, 0, 1024)
-
-	for _, v := range ls {
-		b = append(b, v.Name...)
-		b = append(b, sep)
-		b = append(b, v.Value...)
-		b = append(b, sep)
-	}
-	return xxhash.Sum64(b)
-}
-
-// Get returns the value for the label with the given name.
-// Returns an empty string if the label doesn't exist.
-func (ls Labels) Get(name string) string {
-	for _, l := range ls {
-		if l.Name == name {
-			return l.Value
-		}
-	}
-	return ""
-}
-
-// Equals returns whether the two label sets are equal.
-func (ls Labels) Equals(o Labels) bool {
-	if len(ls) != len(o) {
-		return false
-	}
-	for i, l := range ls {
-		if o[i] != l {
-			return false
-		}
-	}
-	return true
-}
-
-// Map returns a string map of the labels.
-func (ls Labels) Map() map[string]string {
-	m := make(map[string]string, len(ls))
-	for _, l := range ls {
-		m[l.Name] = l.Value
-	}
-	return m
-}
-
-// WithoutEmpty returns the labelset without empty labels.
-// May return the same labelset.
-func (ls Labels) WithoutEmpty() Labels {
-	for _, v := range ls {
-		if v.Value == "" {
-			els := make(Labels, 0, len(ls)-1)
-			for _, v := range ls {
-				if v.Value != "" {
-					els = append(els, v)
-				}
-			}
-			return els
-		}
-	}
-	return ls
-}
-
-// New returns a sorted Labels from the given labels.
-// The caller has to guarantee that all label names are unique.
-func New(ls ...Label) Labels {
-	set := make(Labels, 0, len(ls))
-	for _, l := range ls {
-		set = append(set, l)
-	}
-	sort.Sort(set)
-
-	return set
-}
-
-// FromMap returns new sorted Labels from the given map.
-func FromMap(m map[string]string) Labels {
-	l := make(Labels, 0, len(m))
-	for k, v := range m {
-		if v != "" {
-			l = append(l, Label{Name: k, Value: v})
-		}
-	}
-	sort.Sort(l)
-
-	return l
-}
-
-// FromStrings creates new labels from pairs of strings.
-func FromStrings(ss ...string) Labels {
-	if len(ss)%2 != 0 {
-		panic("invalid number of strings")
-	}
-	var res Labels
-	for i := 0; i < len(ss); i += 2 {
-		if ss[i+1] != "" {
-			res = append(res, Label{Name: ss[i], Value: ss[i+1]})
-		}
-	}
-
-	sort.Sort(res)
-	return res
-}
-
-// Compare compares the two label sets.
-// The result will be 0 if a==b, <0 if a < b, and >0 if a > b.
-func Compare(a, b Labels) int {
-	l := len(a)
-	if len(b) < l {
-		l = len(b)
-	}
-
-	for i := 0; i < l; i++ {
-		if d := strings.Compare(a[i].Name, b[i].Name); d != 0 {
-			return d
-		}
-		if d := strings.Compare(a[i].Value, b[i].Value); d != 0 {
-			return d
-		}
-	}
-	// If all labels so far were in common, the set with fewer labels comes first.
-	return len(a) - len(b)
-}
-
-// Slice is a sortable slice of label sets.
-type Slice []Labels
-
-func (s Slice) Len() int           { return len(s) }
-func (s Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-func (s Slice) Less(i, j int) bool { return Compare(s[i], s[j]) < 0 }
-
-// ReadLabels reads up to n label sets in a JSON formatted file fn. It is mostly useful
-// to load testing data.
-func ReadLabels(fn string, n int) ([]Labels, error) {
-	f, err := os.Open(fn)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	scanner := bufio.NewScanner(f)
-
-	var mets []Labels
-	hashes := map[uint64]struct{}{}
-	i := 0
-
-	for scanner.Scan() && i < n {
-		m := make(Labels, 0, 10)
-
-		r := strings.NewReplacer("\"", "", "{", "", "}", "")
-		s := r.Replace(scanner.Text())
-
-		labelChunks := strings.Split(s, ",")
-		for _, labelChunk := range labelChunks {
-			split := strings.Split(labelChunk, ":")
-			m = append(m, Label{Name: split[0], Value: split[1]})
-		}
-		// Order of the k/v labels matters, don't assume we'll always receive them already sorted.
-		sort.Sort(m)
-
-		h := m.Hash()
-		if _, ok := hashes[h]; ok {
-			continue
-		}
-		mets = append(mets, m)
-		hashes[h] = struct{}{}
-		i++
-	}
-
-	if i != n {
-		return mets, errors.Errorf("requested %d metrics but found %d", n, i)
-	}
-	return mets, nil
-}
diff --git a/vendor/github.com/prometheus/tsdb/labels/selector.go b/vendor/github.com/prometheus/tsdb/labels/selector.go
deleted file mode 100644
index c94ebb3321..0000000000
--- a/vendor/github.com/prometheus/tsdb/labels/selector.go
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright 2017 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.
-
-package labels
-
-import (
-	"fmt"
-	"regexp"
-)
-
-// Selector holds constraints for matching against a label set.
-type Selector []Matcher
-
-// Matches returns whether the labels satisfy all matchers.
-func (s Selector) Matches(labels Labels) bool {
-	for _, m := range s {
-		if v := labels.Get(m.Name()); !m.Matches(v) {
-			return false
-		}
-	}
-	return true
-}
-
-// Matcher specifies a constraint for the value of a label.
-type Matcher interface {
-	// Name returns the label name the matcher should apply to.
-	Name() string
-	// Matches checks whether a value fulfills the constraints.
-	Matches(v string) bool
-	// String returns a human readable matcher.
-	String() string
-}
-
-// EqualMatcher matches on equality.
-type EqualMatcher struct {
-	name, value string
-}
-
-// Name implements Matcher interface.
-func (m EqualMatcher) Name() string { return m.name }
-
-// Matches implements Matcher interface.
-func (m EqualMatcher) Matches(v string) bool { return v == m.value }
-
-// String implements Matcher interface.
-func (m EqualMatcher) String() string { return fmt.Sprintf("%s=%q", m.name, m.value) }
-
-// Value returns the matched value.
-func (m EqualMatcher) Value() string { return m.value }
-
-// NewEqualMatcher returns a new matcher matching an exact label value.
-func NewEqualMatcher(name, value string) Matcher {
-	return &EqualMatcher{name: name, value: value}
-}
-
-type RegexpMatcher struct {
-	name string
-	re   *regexp.Regexp
-}
-
-func (m RegexpMatcher) Name() string          { return m.name }
-func (m RegexpMatcher) Matches(v string) bool { return m.re.MatchString(v) }
-func (m RegexpMatcher) String() string        { return fmt.Sprintf("%s=~%q", m.name, m.re.String()) }
-func (m RegexpMatcher) Value() string         { return m.re.String() }
-
-// NewRegexpMatcher returns a new matcher verifying that a value matches
-// the regular expression pattern.
-func NewRegexpMatcher(name, pattern string) (Matcher, error) {
-	re, err := regexp.Compile(pattern)
-	if err != nil {
-		return nil, err
-	}
-	return &RegexpMatcher{name: name, re: re}, nil
-}
-
-// NewMustRegexpMatcher returns a new matcher verifying that a value matches
-// the regular expression pattern. Will panic if the pattern is not a valid
-// regular expression.
-func NewMustRegexpMatcher(name, pattern string) Matcher {
-	re, err := regexp.Compile(pattern)
-	if err != nil {
-		panic(err)
-	}
-	return &RegexpMatcher{name: name, re: re}
-
-}
-
-// NotMatcher inverts the matching result for a matcher.
-type NotMatcher struct {
-	Matcher
-}
-
-func (m NotMatcher) Matches(v string) bool { return !m.Matcher.Matches(v) }
-func (m NotMatcher) String() string        { return fmt.Sprintf("not(%s)", m.Matcher.String()) }
-
-// Not inverts the matcher's matching result.
-func Not(m Matcher) Matcher {
-	return &NotMatcher{m}
-}
diff --git a/vendor/github.com/prometheus/tsdb/querier.go b/vendor/github.com/prometheus/tsdb/querier.go
deleted file mode 100644
index fbd9493f4f..0000000000
--- a/vendor/github.com/prometheus/tsdb/querier.go
+++ /dev/null
@@ -1,1212 +0,0 @@
-// Copyright 2017 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.
-
-package tsdb
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-	"unicode/utf8"
-
-	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/chunkenc"
-	"github.com/prometheus/tsdb/chunks"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/index"
-	"github.com/prometheus/tsdb/labels"
-)
-
-// Querier provides querying access over time series data of a fixed
-// time range.
-type Querier interface {
-	// Select returns a set of series that matches the given label matchers.
-	Select(...labels.Matcher) (SeriesSet, error)
-
-	// LabelValues returns all potential values for a label name.
-	LabelValues(string) ([]string, error)
-
-	// LabelValuesFor returns all potential values for a label name.
-	// under the constraint of another label.
-	LabelValuesFor(string, labels.Label) ([]string, error)
-
-	// LabelNames returns all the unique label names present in the block in sorted order.
-	LabelNames() ([]string, error)
-
-	// Close releases the resources of the Querier.
-	Close() error
-}
-
-// Series exposes a single time series.
-type Series interface {
-	// Labels returns the complete set of labels identifying the series.
-	Labels() labels.Labels
-
-	// Iterator returns a new iterator of the data of the series.
-	Iterator() SeriesIterator
-}
-
-// querier aggregates querying results from time blocks within
-// a single partition.
-type querier struct {
-	blocks []Querier
-}
-
-func (q *querier) LabelValues(n string) ([]string, error) {
-	return q.lvals(q.blocks, n)
-}
-
-// LabelNames returns all the unique label names present querier blocks.
-func (q *querier) LabelNames() ([]string, error) {
-	labelNamesMap := make(map[string]struct{})
-	for _, b := range q.blocks {
-		names, err := b.LabelNames()
-		if err != nil {
-			return nil, errors.Wrap(err, "LabelNames() from Querier")
-		}
-		for _, name := range names {
-			labelNamesMap[name] = struct{}{}
-		}
-	}
-
-	labelNames := make([]string, 0, len(labelNamesMap))
-	for name := range labelNamesMap {
-		labelNames = append(labelNames, name)
-	}
-	sort.Strings(labelNames)
-
-	return labelNames, nil
-}
-
-func (q *querier) lvals(qs []Querier, n string) ([]string, error) {
-	if len(qs) == 0 {
-		return nil, nil
-	}
-	if len(qs) == 1 {
-		return qs[0].LabelValues(n)
-	}
-	l := len(qs) / 2
-	s1, err := q.lvals(qs[:l], n)
-	if err != nil {
-		return nil, err
-	}
-	s2, err := q.lvals(qs[l:], n)
-	if err != nil {
-		return nil, err
-	}
-	return mergeStrings(s1, s2), nil
-}
-
-func (q *querier) LabelValuesFor(string, labels.Label) ([]string, error) {
-	return nil, fmt.Errorf("not implemented")
-}
-
-func (q *querier) Select(ms ...labels.Matcher) (SeriesSet, error) {
-	return q.sel(q.blocks, ms)
-}
-
-func (q *querier) sel(qs []Querier, ms []labels.Matcher) (SeriesSet, error) {
-	if len(qs) == 0 {
-		return EmptySeriesSet(), nil
-	}
-	if len(qs) == 1 {
-		return qs[0].Select(ms...)
-	}
-	l := len(qs) / 2
-
-	a, err := q.sel(qs[:l], ms)
-	if err != nil {
-		return nil, err
-	}
-	b, err := q.sel(qs[l:], ms)
-	if err != nil {
-		return nil, err
-	}
-	return newMergedSeriesSet(a, b), nil
-}
-
-func (q *querier) Close() error {
-	var merr tsdb_errors.MultiError
-
-	for _, bq := range q.blocks {
-		merr.Add(bq.Close())
-	}
-	return merr.Err()
-}
-
-// verticalQuerier aggregates querying results from time blocks within
-// a single partition. The block time ranges can be overlapping.
-type verticalQuerier struct {
-	querier
-}
-
-func (q *verticalQuerier) Select(ms ...labels.Matcher) (SeriesSet, error) {
-	return q.sel(q.blocks, ms)
-}
-
-func (q *verticalQuerier) sel(qs []Querier, ms []labels.Matcher) (SeriesSet, error) {
-	if len(qs) == 0 {
-		return EmptySeriesSet(), nil
-	}
-	if len(qs) == 1 {
-		return qs[0].Select(ms...)
-	}
-	l := len(qs) / 2
-
-	a, err := q.sel(qs[:l], ms)
-	if err != nil {
-		return nil, err
-	}
-	b, err := q.sel(qs[l:], ms)
-	if err != nil {
-		return nil, err
-	}
-	return newMergedVerticalSeriesSet(a, b), nil
-}
-
-// NewBlockQuerier returns a querier against the reader.
-func NewBlockQuerier(b BlockReader, mint, maxt int64) (Querier, error) {
-	indexr, err := b.Index()
-	if err != nil {
-		return nil, errors.Wrapf(err, "open index reader")
-	}
-	chunkr, err := b.Chunks()
-	if err != nil {
-		indexr.Close()
-		return nil, errors.Wrapf(err, "open chunk reader")
-	}
-	tombsr, err := b.Tombstones()
-	if err != nil {
-		indexr.Close()
-		chunkr.Close()
-		return nil, errors.Wrapf(err, "open tombstone reader")
-	}
-	return &blockQuerier{
-		mint:       mint,
-		maxt:       maxt,
-		index:      indexr,
-		chunks:     chunkr,
-		tombstones: tombsr,
-	}, nil
-}
-
-// blockQuerier provides querying access to a single block database.
-type blockQuerier struct {
-	index      IndexReader
-	chunks     ChunkReader
-	tombstones TombstoneReader
-
-	closed bool
-
-	mint, maxt int64
-}
-
-func (q *blockQuerier) Select(ms ...labels.Matcher) (SeriesSet, error) {
-	base, err := LookupChunkSeries(q.index, q.tombstones, ms...)
-	if err != nil {
-		return nil, err
-	}
-	return &blockSeriesSet{
-		set: &populatedChunkSeries{
-			set:    base,
-			chunks: q.chunks,
-			mint:   q.mint,
-			maxt:   q.maxt,
-		},
-
-		mint: q.mint,
-		maxt: q.maxt,
-	}, nil
-}
-
-func (q *blockQuerier) LabelValues(name string) ([]string, error) {
-	tpls, err := q.index.LabelValues(name)
-	if err != nil {
-		return nil, err
-	}
-	res := make([]string, 0, tpls.Len())
-
-	for i := 0; i < tpls.Len(); i++ {
-		vals, err := tpls.At(i)
-		if err != nil {
-			return nil, err
-		}
-		res = append(res, vals[0])
-	}
-	return res, nil
-}
-
-func (q *blockQuerier) LabelNames() ([]string, error) {
-	return q.index.LabelNames()
-}
-
-func (q *blockQuerier) LabelValuesFor(string, labels.Label) ([]string, error) {
-	return nil, fmt.Errorf("not implemented")
-}
-
-func (q *blockQuerier) Close() error {
-	if q.closed {
-		return errors.New("block querier already closed")
-	}
-
-	var merr tsdb_errors.MultiError
-	merr.Add(q.index.Close())
-	merr.Add(q.chunks.Close())
-	merr.Add(q.tombstones.Close())
-	q.closed = true
-	return merr.Err()
-}
-
-// Bitmap used by func isRegexMetaCharacter to check whether a character needs to be escaped.
-var regexMetaCharacterBytes [16]byte
-
-// isRegexMetaCharacter reports whether byte b needs to be escaped.
-func isRegexMetaCharacter(b byte) bool {
-	return b < utf8.RuneSelf && regexMetaCharacterBytes[b%16]&(1<<(b/16)) != 0
-}
-
-func init() {
-	for _, b := range []byte(`.+*?()|[]{}^$`) {
-		regexMetaCharacterBytes[b%16] |= 1 << (b / 16)
-	}
-}
-
-func findSetMatches(pattern string) []string {
-	// Return empty matches if the wrapper from Prometheus is missing.
-	if len(pattern) < 6 || pattern[:4] != "^(?:" || pattern[len(pattern)-2:] != ")$" {
-		return nil
-	}
-	escaped := false
-	sets := []*strings.Builder{&strings.Builder{}}
-	for i := 4; i < len(pattern)-2; i++ {
-		if escaped {
-			switch {
-			case isRegexMetaCharacter(pattern[i]):
-				sets[len(sets)-1].WriteByte(pattern[i])
-			case pattern[i] == '\\':
-				sets[len(sets)-1].WriteByte('\\')
-			default:
-				return nil
-			}
-			escaped = false
-		} else {
-			switch {
-			case isRegexMetaCharacter(pattern[i]):
-				if pattern[i] == '|' {
-					sets = append(sets, &strings.Builder{})
-				} else {
-					return nil
-				}
-			case pattern[i] == '\\':
-				escaped = true
-			default:
-				sets[len(sets)-1].WriteByte(pattern[i])
-			}
-		}
-	}
-	matches := make([]string, 0, len(sets))
-	for _, s := range sets {
-		if s.Len() > 0 {
-			matches = append(matches, s.String())
-		}
-	}
-	return matches
-}
-
-// PostingsForMatchers assembles a single postings iterator against the index reader
-// based on the given matchers.
-func PostingsForMatchers(ix IndexReader, ms ...labels.Matcher) (index.Postings, error) {
-	var its, notIts []index.Postings
-	// See which label must be non-empty.
-	labelMustBeSet := make(map[string]bool, len(ms))
-	for _, m := range ms {
-		if !m.Matches("") {
-			labelMustBeSet[m.Name()] = true
-		}
-	}
-
-	for _, m := range ms {
-		matchesEmpty := m.Matches("")
-		if labelMustBeSet[m.Name()] || !matchesEmpty {
-			// If this matcher must be non-empty, we can be smarter.
-			nm, isNot := m.(*labels.NotMatcher)
-			if isNot && matchesEmpty { // l!="foo"
-				// If the label can't be empty and is a Not and the inner matcher
-				// doesn't match empty, then subtract it out at the end.
-				it, err := postingsForMatcher(ix, nm.Matcher)
-				if err != nil {
-					return nil, err
-				}
-				notIts = append(notIts, it)
-			} else if isNot && !matchesEmpty { // l!=""
-				// If the label can't be empty and is a Not, but the inner matcher can
-				// be empty we need to use inversePostingsForMatcher.
-				it, err := inversePostingsForMatcher(ix, nm.Matcher)
-				if err != nil {
-					return nil, err
-				}
-				its = append(its, it)
-			} else { // l="a"
-				// Non-Not matcher, use normal postingsForMatcher.
-				it, err := postingsForMatcher(ix, m)
-				if err != nil {
-					return nil, err
-				}
-				its = append(its, it)
-			}
-		} else { // l=""
-			// If the matchers for a labelname selects an empty value, it selects all
-			// the series which don't have the label name set too. See:
-			// https://github.com/prometheus/prometheus/issues/3575 and
-			// https://github.com/prometheus/prometheus/pull/3578#issuecomment-351653555
-			it, err := inversePostingsForMatcher(ix, m)
-			if err != nil {
-				return nil, err
-			}
-			notIts = append(notIts, it)
-		}
-	}
-
-	// If there's nothing to subtract from, add in everything and remove the notIts later.
-	if len(its) == 0 && len(notIts) != 0 {
-		allPostings, err := ix.Postings(index.AllPostingsKey())
-		if err != nil {
-			return nil, err
-		}
-		its = append(its, allPostings)
-	}
-
-	it := index.Intersect(its...)
-
-	for _, n := range notIts {
-		it = index.Without(it, n)
-	}
-
-	return ix.SortedPostings(it), nil
-}
-
-func postingsForMatcher(ix IndexReader, m labels.Matcher) (index.Postings, error) {
-	// This method will not return postings for missing labels.
-
-	// Fast-path for equal matching.
-	if em, ok := m.(*labels.EqualMatcher); ok {
-		return ix.Postings(em.Name(), em.Value())
-	}
-
-	// Fast-path for set matching.
-	if em, ok := m.(*labels.RegexpMatcher); ok {
-		setMatches := findSetMatches(em.Value())
-		if len(setMatches) > 0 {
-			return postingsForSetMatcher(ix, em.Name(), setMatches)
-		}
-	}
-
-	tpls, err := ix.LabelValues(m.Name())
-	if err != nil {
-		return nil, err
-	}
-
-	var res []string
-	for i := 0; i < tpls.Len(); i++ {
-		vals, err := tpls.At(i)
-		if err != nil {
-			return nil, err
-		}
-		if m.Matches(vals[0]) {
-			res = append(res, vals[0])
-		}
-	}
-
-	if len(res) == 0 {
-		return index.EmptyPostings(), nil
-	}
-
-	var rit []index.Postings
-
-	for _, v := range res {
-		it, err := ix.Postings(m.Name(), v)
-		if err != nil {
-			return nil, err
-		}
-		rit = append(rit, it)
-	}
-
-	return index.Merge(rit...), nil
-}
-
-// inversePostingsForMatcher eeturns the postings for the series with the label name set but not matching the matcher.
-func inversePostingsForMatcher(ix IndexReader, m labels.Matcher) (index.Postings, error) {
-	tpls, err := ix.LabelValues(m.Name())
-	if err != nil {
-		return nil, err
-	}
-
-	var res []string
-	for i := 0; i < tpls.Len(); i++ {
-		vals, err := tpls.At(i)
-		if err != nil {
-			return nil, err
-		}
-
-		if !m.Matches(vals[0]) {
-			res = append(res, vals[0])
-		}
-	}
-
-	var rit []index.Postings
-	for _, v := range res {
-		it, err := ix.Postings(m.Name(), v)
-		if err != nil {
-			return nil, err
-		}
-
-		rit = append(rit, it)
-	}
-
-	return index.Merge(rit...), nil
-}
-
-func postingsForSetMatcher(ix IndexReader, name string, matches []string) (index.Postings, error) {
-	var its []index.Postings
-	for _, match := range matches {
-		if it, err := ix.Postings(name, match); err == nil {
-			its = append(its, it)
-		} else {
-			return nil, err
-		}
-	}
-	return index.Merge(its...), nil
-}
-
-func mergeStrings(a, b []string) []string {
-	maxl := len(a)
-	if len(b) > len(a) {
-		maxl = len(b)
-	}
-	res := make([]string, 0, maxl*10/9)
-
-	for len(a) > 0 && len(b) > 0 {
-		d := strings.Compare(a[0], b[0])
-
-		if d == 0 {
-			res = append(res, a[0])
-			a, b = a[1:], b[1:]
-		} else if d < 0 {
-			res = append(res, a[0])
-			a = a[1:]
-		} else if d > 0 {
-			res = append(res, b[0])
-			b = b[1:]
-		}
-	}
-
-	// Append all remaining elements.
-	res = append(res, a...)
-	res = append(res, b...)
-	return res
-}
-
-// SeriesSet contains a set of series.
-type SeriesSet interface {
-	Next() bool
-	At() Series
-	Err() error
-}
-
-var emptySeriesSet = errSeriesSet{}
-
-// EmptySeriesSet returns a series set that's always empty.
-func EmptySeriesSet() SeriesSet {
-	return emptySeriesSet
-}
-
-// mergedSeriesSet takes two series sets as a single series set. The input series sets
-// must be sorted and sequential in time, i.e. if they have the same label set,
-// the datapoints of a must be before the datapoints of b.
-type mergedSeriesSet struct {
-	a, b SeriesSet
-
-	cur          Series
-	adone, bdone bool
-}
-
-// NewMergedSeriesSet takes two series sets as a single series set. The input series sets
-// must be sorted and sequential in time, i.e. if they have the same label set,
-// the datapoints of a must be before the datapoints of b.
-func NewMergedSeriesSet(a, b SeriesSet) SeriesSet {
-	return newMergedSeriesSet(a, b)
-}
-
-func newMergedSeriesSet(a, b SeriesSet) *mergedSeriesSet {
-	s := &mergedSeriesSet{a: a, b: b}
-	// Initialize first elements of both sets as Next() needs
-	// one element look-ahead.
-	s.adone = !s.a.Next()
-	s.bdone = !s.b.Next()
-
-	return s
-}
-
-func (s *mergedSeriesSet) At() Series {
-	return s.cur
-}
-
-func (s *mergedSeriesSet) Err() error {
-	if s.a.Err() != nil {
-		return s.a.Err()
-	}
-	return s.b.Err()
-}
-
-func (s *mergedSeriesSet) compare() int {
-	if s.adone {
-		return 1
-	}
-	if s.bdone {
-		return -1
-	}
-	return labels.Compare(s.a.At().Labels(), s.b.At().Labels())
-}
-
-func (s *mergedSeriesSet) Next() bool {
-	if s.adone && s.bdone || s.Err() != nil {
-		return false
-	}
-
-	d := s.compare()
-
-	// Both sets contain the current series. Chain them into a single one.
-	if d > 0 {
-		s.cur = s.b.At()
-		s.bdone = !s.b.Next()
-	} else if d < 0 {
-		s.cur = s.a.At()
-		s.adone = !s.a.Next()
-	} else {
-		s.cur = &chainedSeries{series: []Series{s.a.At(), s.b.At()}}
-		s.adone = !s.a.Next()
-		s.bdone = !s.b.Next()
-	}
-	return true
-}
-
-type mergedVerticalSeriesSet struct {
-	a, b         SeriesSet
-	cur          Series
-	adone, bdone bool
-}
-
-// NewMergedVerticalSeriesSet takes two series sets as a single series set.
-// The input series sets must be sorted and
-// the time ranges of the series can be overlapping.
-func NewMergedVerticalSeriesSet(a, b SeriesSet) SeriesSet {
-	return newMergedVerticalSeriesSet(a, b)
-}
-
-func newMergedVerticalSeriesSet(a, b SeriesSet) *mergedVerticalSeriesSet {
-	s := &mergedVerticalSeriesSet{a: a, b: b}
-	// Initialize first elements of both sets as Next() needs
-	// one element look-ahead.
-	s.adone = !s.a.Next()
-	s.bdone = !s.b.Next()
-
-	return s
-}
-
-func (s *mergedVerticalSeriesSet) At() Series {
-	return s.cur
-}
-
-func (s *mergedVerticalSeriesSet) Err() error {
-	if s.a.Err() != nil {
-		return s.a.Err()
-	}
-	return s.b.Err()
-}
-
-func (s *mergedVerticalSeriesSet) compare() int {
-	if s.adone {
-		return 1
-	}
-	if s.bdone {
-		return -1
-	}
-	return labels.Compare(s.a.At().Labels(), s.b.At().Labels())
-}
-
-func (s *mergedVerticalSeriesSet) Next() bool {
-	if s.adone && s.bdone || s.Err() != nil {
-		return false
-	}
-
-	d := s.compare()
-
-	// Both sets contain the current series. Chain them into a single one.
-	if d > 0 {
-		s.cur = s.b.At()
-		s.bdone = !s.b.Next()
-	} else if d < 0 {
-		s.cur = s.a.At()
-		s.adone = !s.a.Next()
-	} else {
-		s.cur = &verticalChainedSeries{series: []Series{s.a.At(), s.b.At()}}
-		s.adone = !s.a.Next()
-		s.bdone = !s.b.Next()
-	}
-	return true
-}
-
-// ChunkSeriesSet exposes the chunks and intervals of a series instead of the
-// actual series itself.
-type ChunkSeriesSet interface {
-	Next() bool
-	At() (labels.Labels, []chunks.Meta, Intervals)
-	Err() error
-}
-
-// baseChunkSeries loads the label set and chunk references for a postings
-// list from an index. It filters out series that have labels set that should be unset.
-type baseChunkSeries struct {
-	p          index.Postings
-	index      IndexReader
-	tombstones TombstoneReader
-
-	lset      labels.Labels
-	chks      []chunks.Meta
-	intervals Intervals
-	err       error
-}
-
-// LookupChunkSeries retrieves all series for the given matchers and returns a ChunkSeriesSet
-// over them. It drops chunks based on tombstones in the given reader.
-func LookupChunkSeries(ir IndexReader, tr TombstoneReader, ms ...labels.Matcher) (ChunkSeriesSet, error) {
-	if tr == nil {
-		tr = newMemTombstones()
-	}
-	p, err := PostingsForMatchers(ir, ms...)
-	if err != nil {
-		return nil, err
-	}
-	return &baseChunkSeries{
-		p:          p,
-		index:      ir,
-		tombstones: tr,
-	}, nil
-}
-
-func (s *baseChunkSeries) At() (labels.Labels, []chunks.Meta, Intervals) {
-	return s.lset, s.chks, s.intervals
-}
-
-func (s *baseChunkSeries) Err() error { return s.err }
-
-func (s *baseChunkSeries) Next() bool {
-	var (
-		lset     = make(labels.Labels, len(s.lset))
-		chkMetas = make([]chunks.Meta, len(s.chks))
-		err      error
-	)
-
-	for s.p.Next() {
-		ref := s.p.At()
-		if err := s.index.Series(ref, &lset, &chkMetas); err != nil {
-			// Postings may be stale. Skip if no underlying series exists.
-			if errors.Cause(err) == ErrNotFound {
-				continue
-			}
-			s.err = err
-			return false
-		}
-
-		s.lset = lset
-		s.chks = chkMetas
-		s.intervals, err = s.tombstones.Get(s.p.At())
-		if err != nil {
-			s.err = errors.Wrap(err, "get tombstones")
-			return false
-		}
-
-		if len(s.intervals) > 0 {
-			// Only those chunks that are not entirely deleted.
-			chks := make([]chunks.Meta, 0, len(s.chks))
-			for _, chk := range s.chks {
-				if !(Interval{chk.MinTime, chk.MaxTime}.isSubrange(s.intervals)) {
-					chks = append(chks, chk)
-				}
-			}
-
-			s.chks = chks
-		}
-
-		return true
-	}
-	if err := s.p.Err(); err != nil {
-		s.err = err
-	}
-	return false
-}
-
-// populatedChunkSeries loads chunk data from a store for a set of series
-// with known chunk references. It filters out chunks that do not fit the
-// given time range.
-type populatedChunkSeries struct {
-	set        ChunkSeriesSet
-	chunks     ChunkReader
-	mint, maxt int64
-
-	err       error
-	chks      []chunks.Meta
-	lset      labels.Labels
-	intervals Intervals
-}
-
-func (s *populatedChunkSeries) At() (labels.Labels, []chunks.Meta, Intervals) {
-	return s.lset, s.chks, s.intervals
-}
-
-func (s *populatedChunkSeries) Err() error { return s.err }
-
-func (s *populatedChunkSeries) Next() bool {
-	for s.set.Next() {
-		lset, chks, dranges := s.set.At()
-
-		for len(chks) > 0 {
-			if chks[0].MaxTime >= s.mint {
-				break
-			}
-			chks = chks[1:]
-		}
-
-		// This is to delete in place while iterating.
-		for i, rlen := 0, len(chks); i < rlen; i++ {
-			j := i - (rlen - len(chks))
-			c := &chks[j]
-
-			// Break out at the first chunk that has no overlap with mint, maxt.
-			if c.MinTime > s.maxt {
-				chks = chks[:j]
-				break
-			}
-
-			c.Chunk, s.err = s.chunks.Chunk(c.Ref)
-			if s.err != nil {
-				// This means that the chunk has be garbage collected. Remove it from the list.
-				if s.err == ErrNotFound {
-					s.err = nil
-					// Delete in-place.
-					s.chks = append(chks[:j], chks[j+1:]...)
-				}
-				return false
-			}
-		}
-
-		if len(chks) == 0 {
-			continue
-		}
-
-		s.lset = lset
-		s.chks = chks
-		s.intervals = dranges
-
-		return true
-	}
-	if err := s.set.Err(); err != nil {
-		s.err = err
-	}
-	return false
-}
-
-// blockSeriesSet is a set of series from an inverted index query.
-type blockSeriesSet struct {
-	set ChunkSeriesSet
-	err error
-	cur Series
-
-	mint, maxt int64
-}
-
-func (s *blockSeriesSet) Next() bool {
-	for s.set.Next() {
-		lset, chunks, dranges := s.set.At()
-		s.cur = &chunkSeries{
-			labels: lset,
-			chunks: chunks,
-			mint:   s.mint,
-			maxt:   s.maxt,
-
-			intervals: dranges,
-		}
-		return true
-	}
-	if s.set.Err() != nil {
-		s.err = s.set.Err()
-	}
-	return false
-}
-
-func (s *blockSeriesSet) At() Series { return s.cur }
-func (s *blockSeriesSet) Err() error { return s.err }
-
-// chunkSeries is a series that is backed by a sequence of chunks holding
-// time series data.
-type chunkSeries struct {
-	labels labels.Labels
-	chunks []chunks.Meta // in-order chunk refs
-
-	mint, maxt int64
-
-	intervals Intervals
-}
-
-func (s *chunkSeries) Labels() labels.Labels {
-	return s.labels
-}
-
-func (s *chunkSeries) Iterator() SeriesIterator {
-	return newChunkSeriesIterator(s.chunks, s.intervals, s.mint, s.maxt)
-}
-
-// SeriesIterator iterates over the data of a time series.
-type SeriesIterator interface {
-	// Seek advances the iterator forward to the given timestamp.
-	// If there's no value exactly at t, it advances to the first value
-	// after t.
-	Seek(t int64) bool
-	// At returns the current timestamp/value pair.
-	At() (t int64, v float64)
-	// Next advances the iterator by one.
-	Next() bool
-	// Err returns the current error.
-	Err() error
-}
-
-// chainedSeries implements a series for a list of time-sorted series.
-// They all must have the same labels.
-type chainedSeries struct {
-	series []Series
-}
-
-func (s *chainedSeries) Labels() labels.Labels {
-	return s.series[0].Labels()
-}
-
-func (s *chainedSeries) Iterator() SeriesIterator {
-	return newChainedSeriesIterator(s.series...)
-}
-
-// chainedSeriesIterator implements a series iterater over a list
-// of time-sorted, non-overlapping iterators.
-type chainedSeriesIterator struct {
-	series []Series // series in time order
-
-	i   int
-	cur SeriesIterator
-}
-
-func newChainedSeriesIterator(s ...Series) *chainedSeriesIterator {
-	return &chainedSeriesIterator{
-		series: s,
-		i:      0,
-		cur:    s[0].Iterator(),
-	}
-}
-
-func (it *chainedSeriesIterator) Seek(t int64) bool {
-	// We just scan the chained series sequentially as they are already
-	// pre-selected by relevant time and should be accessed sequentially anyway.
-	for i, s := range it.series[it.i:] {
-		cur := s.Iterator()
-		if !cur.Seek(t) {
-			continue
-		}
-		it.cur = cur
-		it.i += i
-		return true
-	}
-	return false
-}
-
-func (it *chainedSeriesIterator) Next() bool {
-	if it.cur.Next() {
-		return true
-	}
-	if err := it.cur.Err(); err != nil {
-		return false
-	}
-	if it.i == len(it.series)-1 {
-		return false
-	}
-
-	it.i++
-	it.cur = it.series[it.i].Iterator()
-
-	return it.Next()
-}
-
-func (it *chainedSeriesIterator) At() (t int64, v float64) {
-	return it.cur.At()
-}
-
-func (it *chainedSeriesIterator) Err() error {
-	return it.cur.Err()
-}
-
-// verticalChainedSeries implements a series for a list of time-sorted, time-overlapping series.
-// They all must have the same labels.
-type verticalChainedSeries struct {
-	series []Series
-}
-
-func (s *verticalChainedSeries) Labels() labels.Labels {
-	return s.series[0].Labels()
-}
-
-func (s *verticalChainedSeries) Iterator() SeriesIterator {
-	return newVerticalMergeSeriesIterator(s.series...)
-}
-
-// verticalMergeSeriesIterator implements a series iterater over a list
-// of time-sorted, time-overlapping iterators.
-type verticalMergeSeriesIterator struct {
-	a, b                  SeriesIterator
-	aok, bok, initialized bool
-
-	curT int64
-	curV float64
-}
-
-func newVerticalMergeSeriesIterator(s ...Series) SeriesIterator {
-	if len(s) == 1 {
-		return s[0].Iterator()
-	} else if len(s) == 2 {
-		return &verticalMergeSeriesIterator{
-			a: s[0].Iterator(),
-			b: s[1].Iterator(),
-		}
-	}
-	return &verticalMergeSeriesIterator{
-		a: s[0].Iterator(),
-		b: newVerticalMergeSeriesIterator(s[1:]...),
-	}
-}
-
-func (it *verticalMergeSeriesIterator) Seek(t int64) bool {
-	it.aok, it.bok = it.a.Seek(t), it.b.Seek(t)
-	it.initialized = true
-	return it.Next()
-}
-
-func (it *verticalMergeSeriesIterator) Next() bool {
-	if !it.initialized {
-		it.aok = it.a.Next()
-		it.bok = it.b.Next()
-		it.initialized = true
-	}
-
-	if !it.aok && !it.bok {
-		return false
-	}
-
-	if !it.aok {
-		it.curT, it.curV = it.b.At()
-		it.bok = it.b.Next()
-		return true
-	}
-	if !it.bok {
-		it.curT, it.curV = it.a.At()
-		it.aok = it.a.Next()
-		return true
-	}
-
-	acurT, acurV := it.a.At()
-	bcurT, bcurV := it.b.At()
-	if acurT < bcurT {
-		it.curT, it.curV = acurT, acurV
-		it.aok = it.a.Next()
-	} else if acurT > bcurT {
-		it.curT, it.curV = bcurT, bcurV
-		it.bok = it.b.Next()
-	} else {
-		it.curT, it.curV = bcurT, bcurV
-		it.aok = it.a.Next()
-		it.bok = it.b.Next()
-	}
-	return true
-}
-
-func (it *verticalMergeSeriesIterator) At() (t int64, v float64) {
-	return it.curT, it.curV
-}
-
-func (it *verticalMergeSeriesIterator) Err() error {
-	if it.a.Err() != nil {
-		return it.a.Err()
-	}
-	return it.b.Err()
-}
-
-// chunkSeriesIterator implements a series iterator on top
-// of a list of time-sorted, non-overlapping chunks.
-type chunkSeriesIterator struct {
-	chunks []chunks.Meta
-
-	i          int
-	cur        chunkenc.Iterator
-	bufDelIter *deletedIterator
-
-	maxt, mint int64
-
-	intervals Intervals
-}
-
-func newChunkSeriesIterator(cs []chunks.Meta, dranges Intervals, mint, maxt int64) *chunkSeriesIterator {
-	csi := &chunkSeriesIterator{
-		chunks: cs,
-		i:      0,
-
-		mint: mint,
-		maxt: maxt,
-
-		intervals: dranges,
-	}
-	csi.resetCurIterator()
-
-	return csi
-}
-
-func (it *chunkSeriesIterator) resetCurIterator() {
-	if len(it.intervals) == 0 {
-		it.cur = it.chunks[it.i].Chunk.Iterator(it.cur)
-		return
-	}
-	if it.bufDelIter == nil {
-		it.bufDelIter = &deletedIterator{
-			intervals: it.intervals,
-		}
-	}
-	it.bufDelIter.it = it.chunks[it.i].Chunk.Iterator(it.bufDelIter.it)
-	it.cur = it.bufDelIter
-}
-
-func (it *chunkSeriesIterator) Seek(t int64) (ok bool) {
-	if t > it.maxt {
-		return false
-	}
-
-	// Seek to the first valid value after t.
-	if t < it.mint {
-		t = it.mint
-	}
-
-	for ; it.chunks[it.i].MaxTime < t; it.i++ {
-		if it.i == len(it.chunks)-1 {
-			return false
-		}
-	}
-
-	it.resetCurIterator()
-
-	for it.cur.Next() {
-		t0, _ := it.cur.At()
-		if t0 >= t {
-			return true
-		}
-	}
-	return false
-}
-
-func (it *chunkSeriesIterator) At() (t int64, v float64) {
-	return it.cur.At()
-}
-
-func (it *chunkSeriesIterator) Next() bool {
-	if it.cur.Next() {
-		t, _ := it.cur.At()
-
-		if t < it.mint {
-			if !it.Seek(it.mint) {
-				return false
-			}
-			t, _ = it.At()
-
-			return t <= it.maxt
-		}
-		if t > it.maxt {
-			return false
-		}
-		return true
-	}
-	if err := it.cur.Err(); err != nil {
-		return false
-	}
-	if it.i == len(it.chunks)-1 {
-		return false
-	}
-
-	it.i++
-	it.resetCurIterator()
-
-	return it.Next()
-}
-
-func (it *chunkSeriesIterator) Err() error {
-	return it.cur.Err()
-}
-
-// deletedIterator wraps an Iterator and makes sure any deleted metrics are not
-// returned.
-type deletedIterator struct {
-	it chunkenc.Iterator
-
-	intervals Intervals
-}
-
-func (it *deletedIterator) At() (int64, float64) {
-	return it.it.At()
-}
-
-func (it *deletedIterator) Next() bool {
-Outer:
-	for it.it.Next() {
-		ts, _ := it.it.At()
-
-		for _, tr := range it.intervals {
-			if tr.inBounds(ts) {
-				continue Outer
-			}
-
-			if ts > tr.Maxt {
-				it.intervals = it.intervals[1:]
-				continue
-			}
-
-			return true
-		}
-
-		return true
-	}
-
-	return false
-}
-
-func (it *deletedIterator) Err() error {
-	return it.it.Err()
-}
-
-type errSeriesSet struct {
-	err error
-}
-
-func (s errSeriesSet) Next() bool { return false }
-func (s errSeriesSet) At() Series { return nil }
-func (s errSeriesSet) Err() error { return s.err }
diff --git a/vendor/github.com/prometheus/tsdb/record.go b/vendor/github.com/prometheus/tsdb/record.go
deleted file mode 100644
index 8d9c5751da..0000000000
--- a/vendor/github.com/prometheus/tsdb/record.go
+++ /dev/null
@@ -1,208 +0,0 @@
-// Copyright 2018 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.
-
-package tsdb
-
-import (
-	"math"
-	"sort"
-
-	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/encoding"
-	"github.com/prometheus/tsdb/labels"
-)
-
-// RecordType represents the data type of a record.
-type RecordType uint8
-
-const (
-	// RecordInvalid is returned for unrecognised WAL record types.
-	RecordInvalid RecordType = 255
-	// RecordSeries is used to match WAL records of type Series.
-	RecordSeries RecordType = 1
-	// RecordSamples is used to match WAL records of type Samples.
-	RecordSamples RecordType = 2
-	// RecordTombstones is used to match WAL records of type Tombstones.
-	RecordTombstones RecordType = 3
-)
-
-// RecordDecoder decodes series, sample, and tombstone records.
-// The zero value is ready to use.
-type RecordDecoder struct {
-}
-
-// Type returns the type of the record.
-// Return RecordInvalid if no valid record type is found.
-func (d *RecordDecoder) Type(rec []byte) RecordType {
-	if len(rec) < 1 {
-		return RecordInvalid
-	}
-	switch t := RecordType(rec[0]); t {
-	case RecordSeries, RecordSamples, RecordTombstones:
-		return t
-	}
-	return RecordInvalid
-}
-
-// Series appends series in rec to the given slice.
-func (d *RecordDecoder) Series(rec []byte, series []RefSeries) ([]RefSeries, error) {
-	dec := encoding.Decbuf{B: rec}
-
-	if RecordType(dec.Byte()) != RecordSeries {
-		return nil, errors.New("invalid record type")
-	}
-	for len(dec.B) > 0 && dec.Err() == nil {
-		ref := dec.Be64()
-
-		lset := make(labels.Labels, dec.Uvarint())
-
-		for i := range lset {
-			lset[i].Name = dec.UvarintStr()
-			lset[i].Value = dec.UvarintStr()
-		}
-		sort.Sort(lset)
-
-		series = append(series, RefSeries{
-			Ref:    ref,
-			Labels: lset,
-		})
-	}
-	if dec.Err() != nil {
-		return nil, dec.Err()
-	}
-	if len(dec.B) > 0 {
-		return nil, errors.Errorf("unexpected %d bytes left in entry", len(dec.B))
-	}
-	return series, nil
-}
-
-// Samples appends samples in rec to the given slice.
-func (d *RecordDecoder) Samples(rec []byte, samples []RefSample) ([]RefSample, error) {
-	dec := encoding.Decbuf{B: rec}
-
-	if RecordType(dec.Byte()) != RecordSamples {
-		return nil, errors.New("invalid record type")
-	}
-	if dec.Len() == 0 {
-		return samples, nil
-	}
-	var (
-		baseRef  = dec.Be64()
-		baseTime = dec.Be64int64()
-	)
-	for len(dec.B) > 0 && dec.Err() == nil {
-		dref := dec.Varint64()
-		dtime := dec.Varint64()
-		val := dec.Be64()
-
-		samples = append(samples, RefSample{
-			Ref: uint64(int64(baseRef) + dref),
-			T:   baseTime + dtime,
-			V:   math.Float64frombits(val),
-		})
-	}
-
-	if dec.Err() != nil {
-		return nil, errors.Wrapf(dec.Err(), "decode error after %d samples", len(samples))
-	}
-	if len(dec.B) > 0 {
-		return nil, errors.Errorf("unexpected %d bytes left in entry", len(dec.B))
-	}
-	return samples, nil
-}
-
-// Tombstones appends tombstones in rec to the given slice.
-func (d *RecordDecoder) Tombstones(rec []byte, tstones []Stone) ([]Stone, error) {
-	dec := encoding.Decbuf{B: rec}
-
-	if RecordType(dec.Byte()) != RecordTombstones {
-		return nil, errors.New("invalid record type")
-	}
-	for dec.Len() > 0 && dec.Err() == nil {
-		tstones = append(tstones, Stone{
-			ref: dec.Be64(),
-			intervals: Intervals{
-				{Mint: dec.Varint64(), Maxt: dec.Varint64()},
-			},
-		})
-	}
-	if dec.Err() != nil {
-		return nil, dec.Err()
-	}
-	if len(dec.B) > 0 {
-		return nil, errors.Errorf("unexpected %d bytes left in entry", len(dec.B))
-	}
-	return tstones, nil
-}
-
-// RecordEncoder encodes series, sample, and tombstones records.
-// The zero value is ready to use.
-type RecordEncoder struct {
-}
-
-// Series appends the encoded series to b and returns the resulting slice.
-func (e *RecordEncoder) Series(series []RefSeries, b []byte) []byte {
-	buf := encoding.Encbuf{B: b}
-	buf.PutByte(byte(RecordSeries))
-
-	for _, s := range series {
-		buf.PutBE64(s.Ref)
-		buf.PutUvarint(len(s.Labels))
-
-		for _, l := range s.Labels {
-			buf.PutUvarintStr(l.Name)
-			buf.PutUvarintStr(l.Value)
-		}
-	}
-	return buf.Get()
-}
-
-// Samples appends the encoded samples to b and returns the resulting slice.
-func (e *RecordEncoder) Samples(samples []RefSample, b []byte) []byte {
-	buf := encoding.Encbuf{B: b}
-	buf.PutByte(byte(RecordSamples))
-
-	if len(samples) == 0 {
-		return buf.Get()
-	}
-
-	// Store base timestamp and base reference number of first sample.
-	// All samples encode their timestamp and ref as delta to those.
-	first := samples[0]
-
-	buf.PutBE64(first.Ref)
-	buf.PutBE64int64(first.T)
-
-	for _, s := range samples {
-		buf.PutVarint64(int64(s.Ref) - int64(first.Ref))
-		buf.PutVarint64(s.T - first.T)
-		buf.PutBE64(math.Float64bits(s.V))
-	}
-	return buf.Get()
-}
-
-// Tombstones appends the encoded tombstones to b and returns the resulting slice.
-func (e *RecordEncoder) Tombstones(tstones []Stone, b []byte) []byte {
-	buf := encoding.Encbuf{B: b}
-	buf.PutByte(byte(RecordTombstones))
-
-	for _, s := range tstones {
-		for _, iv := range s.intervals {
-			buf.PutBE64(s.ref)
-			buf.PutVarint64(iv.Mint)
-			buf.PutVarint64(iv.Maxt)
-		}
-	}
-	return buf.Get()
-}
diff --git a/vendor/github.com/prometheus/tsdb/repair.go b/vendor/github.com/prometheus/tsdb/repair.go
deleted file mode 100644
index 1d299047a0..0000000000
--- a/vendor/github.com/prometheus/tsdb/repair.go
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright 2018 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.
-
-package tsdb
-
-import (
-	"encoding/json"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
-	"github.com/pkg/errors"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-)
-
-// repairBadIndexVersion repairs an issue in index and meta.json persistence introduced in
-// commit 129773b41a565fde5156301e37f9a87158030443.
-func repairBadIndexVersion(logger log.Logger, dir string) error {
-	// All blocks written by Prometheus 2.1 with a meta.json version of 2 are affected.
-	// We must actually set the index file version to 2 and revert the meta.json version back to 1.
-	dirs, err := blockDirs(dir)
-	if err != nil {
-		return errors.Wrapf(err, "list block dirs in %q", dir)
-	}
-
-	wrapErr := func(err error, d string) error {
-		return errors.Wrapf(err, "block dir: %q", d)
-	}
-
-	tmpFiles := make([]string, 0, len(dir))
-	defer func() {
-		for _, tmp := range tmpFiles {
-			if err := os.RemoveAll(tmp); err != nil {
-				level.Error(logger).Log("msg", "remove tmp file", "err", err.Error())
-			}
-		}
-	}()
-
-	for _, d := range dirs {
-		meta, err := readBogusMetaFile(d)
-		if err != nil {
-			return wrapErr(err, d)
-		}
-		if meta.Version == 1 {
-			level.Info(logger).Log(
-				"msg", "found healthy block",
-				"mint", meta.MinTime,
-				"maxt", meta.MaxTime,
-				"ulid", meta.ULID,
-			)
-			continue
-		}
-		level.Info(logger).Log(
-			"msg", "fixing broken block",
-			"mint", meta.MinTime,
-			"maxt", meta.MaxTime,
-			"ulid", meta.ULID,
-		)
-
-		repl, err := os.Create(filepath.Join(d, "index.repaired"))
-		if err != nil {
-			return wrapErr(err, d)
-		}
-		tmpFiles = append(tmpFiles, repl.Name())
-
-		broken, err := os.Open(filepath.Join(d, indexFilename))
-		if err != nil {
-			return wrapErr(err, d)
-		}
-		if _, err := io.Copy(repl, broken); err != nil {
-			return wrapErr(err, d)
-		}
-
-		var merr tsdb_errors.MultiError
-
-		// Set the 5th byte to 2 to indicate the correct file format version.
-		if _, err := repl.WriteAt([]byte{2}, 4); err != nil {
-			merr.Add(wrapErr(err, d))
-			merr.Add(wrapErr(repl.Close(), d))
-			return merr.Err()
-		}
-		if err := repl.Sync(); err != nil {
-			merr.Add(wrapErr(err, d))
-			merr.Add(wrapErr(repl.Close(), d))
-			return merr.Err()
-		}
-		if err := repl.Close(); err != nil {
-			return wrapErr(err, d)
-		}
-		if err := broken.Close(); err != nil {
-			return wrapErr(err, d)
-		}
-		if err := fileutil.Replace(repl.Name(), broken.Name()); err != nil {
-			return wrapErr(err, d)
-		}
-		// Reset version of meta.json to 1.
-		meta.Version = 1
-		if _, err := writeMetaFile(logger, d, meta); err != nil {
-			return wrapErr(err, d)
-		}
-	}
-	return nil
-}
-
-func readBogusMetaFile(dir string) (*BlockMeta, error) {
-	b, err := ioutil.ReadFile(filepath.Join(dir, metaFilename))
-	if err != nil {
-		return nil, err
-	}
-	var m BlockMeta
-
-	if err := json.Unmarshal(b, &m); err != nil {
-		return nil, err
-	}
-	if m.Version != 1 && m.Version != 2 {
-		return nil, errors.Errorf("unexpected meta file version %d", m.Version)
-	}
-	return &m, nil
-}
diff --git a/vendor/github.com/prometheus/tsdb/tombstones.go b/vendor/github.com/prometheus/tsdb/tombstones.go
deleted file mode 100644
index d7b76230c0..0000000000
--- a/vendor/github.com/prometheus/tsdb/tombstones.go
+++ /dev/null
@@ -1,304 +0,0 @@
-// Copyright 2017 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.
-
-package tsdb
-
-import (
-	"encoding/binary"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"sync"
-
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
-	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb/encoding"
-	tsdb_errors "github.com/prometheus/tsdb/errors"
-	"github.com/prometheus/tsdb/fileutil"
-)
-
-const tombstoneFilename = "tombstones"
-
-const (
-	// MagicTombstone is 4 bytes at the head of a tombstone file.
-	MagicTombstone = 0x0130BA30
-
-	tombstoneFormatV1 = 1
-)
-
-// TombstoneReader gives access to tombstone intervals by series reference.
-type TombstoneReader interface {
-	// Get returns deletion intervals for the series with the given reference.
-	Get(ref uint64) (Intervals, error)
-
-	// Iter calls the given function for each encountered interval.
-	Iter(func(uint64, Intervals) error) error
-
-	// Total returns the total count of tombstones.
-	Total() uint64
-
-	// Close any underlying resources
-	Close() error
-}
-
-func writeTombstoneFile(logger log.Logger, dir string, tr TombstoneReader) (int64, error) {
-	path := filepath.Join(dir, tombstoneFilename)
-	tmp := path + ".tmp"
-	hash := newCRC32()
-	var size int
-
-	f, err := os.Create(tmp)
-	if err != nil {
-		return 0, err
-	}
-	defer func() {
-		if f != nil {
-			if err := f.Close(); err != nil {
-				level.Error(logger).Log("msg", "close tmp file", "err", err.Error())
-			}
-		}
-		if err := os.RemoveAll(tmp); err != nil {
-			level.Error(logger).Log("msg", "remove tmp file", "err", err.Error())
-		}
-	}()
-
-	buf := encoding.Encbuf{B: make([]byte, 3*binary.MaxVarintLen64)}
-	buf.Reset()
-	// Write the meta.
-	buf.PutBE32(MagicTombstone)
-	buf.PutByte(tombstoneFormatV1)
-	n, err := f.Write(buf.Get())
-	if err != nil {
-		return 0, err
-	}
-	size += n
-
-	mw := io.MultiWriter(f, hash)
-
-	if err := tr.Iter(func(ref uint64, ivs Intervals) error {
-		for _, iv := range ivs {
-			buf.Reset()
-
-			buf.PutUvarint64(ref)
-			buf.PutVarint64(iv.Mint)
-			buf.PutVarint64(iv.Maxt)
-
-			n, err = mw.Write(buf.Get())
-			if err != nil {
-				return err
-			}
-			size += n
-		}
-		return nil
-	}); err != nil {
-		return 0, fmt.Errorf("error writing tombstones: %v", err)
-	}
-
-	n, err = f.Write(hash.Sum(nil))
-	if err != nil {
-		return 0, err
-	}
-	size += n
-
-	var merr tsdb_errors.MultiError
-	if merr.Add(f.Sync()); merr.Err() != nil {
-		merr.Add(f.Close())
-		return 0, merr.Err()
-	}
-
-	if err = f.Close(); err != nil {
-		return 0, err
-	}
-	f = nil
-	return int64(size), fileutil.Replace(tmp, path)
-}
-
-// Stone holds the information on the posting and time-range
-// that is deleted.
-type Stone struct {
-	ref       uint64
-	intervals Intervals
-}
-
-func readTombstones(dir string) (TombstoneReader, int64, error) {
-	b, err := ioutil.ReadFile(filepath.Join(dir, tombstoneFilename))
-	if os.IsNotExist(err) {
-		return newMemTombstones(), 0, nil
-	} else if err != nil {
-		return nil, 0, err
-	}
-
-	if len(b) < 5 {
-		return nil, 0, errors.Wrap(encoding.ErrInvalidSize, "tombstones header")
-	}
-
-	d := &encoding.Decbuf{B: b[:len(b)-4]} // 4 for the checksum.
-	if mg := d.Be32(); mg != MagicTombstone {
-		return nil, 0, fmt.Errorf("invalid magic number %x", mg)
-	}
-	if flag := d.Byte(); flag != tombstoneFormatV1 {
-		return nil, 0, fmt.Errorf("invalid tombstone format %x", flag)
-	}
-
-	if d.Err() != nil {
-		return nil, 0, d.Err()
-	}
-
-	// Verify checksum.
-	hash := newCRC32()
-	if _, err := hash.Write(d.Get()); err != nil {
-		return nil, 0, errors.Wrap(err, "write to hash")
-	}
-	if binary.BigEndian.Uint32(b[len(b)-4:]) != hash.Sum32() {
-		return nil, 0, errors.New("checksum did not match")
-	}
-
-	stonesMap := newMemTombstones()
-
-	for d.Len() > 0 {
-		k := d.Uvarint64()
-		mint := d.Varint64()
-		maxt := d.Varint64()
-		if d.Err() != nil {
-			return nil, 0, d.Err()
-		}
-
-		stonesMap.addInterval(k, Interval{mint, maxt})
-	}
-
-	return stonesMap, int64(len(b)), nil
-}
-
-type memTombstones struct {
-	intvlGroups map[uint64]Intervals
-	mtx         sync.RWMutex
-}
-
-// newMemTombstones creates new in memory TombstoneReader
-// that allows adding new intervals.
-func newMemTombstones() *memTombstones {
-	return &memTombstones{intvlGroups: make(map[uint64]Intervals)}
-}
-
-func (t *memTombstones) Get(ref uint64) (Intervals, error) {
-	t.mtx.RLock()
-	defer t.mtx.RUnlock()
-	return t.intvlGroups[ref], nil
-}
-
-func (t *memTombstones) Iter(f func(uint64, Intervals) error) error {
-	t.mtx.RLock()
-	defer t.mtx.RUnlock()
-	for ref, ivs := range t.intvlGroups {
-		if err := f(ref, ivs); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *memTombstones) Total() uint64 {
-	t.mtx.RLock()
-	defer t.mtx.RUnlock()
-
-	total := uint64(0)
-	for _, ivs := range t.intvlGroups {
-		total += uint64(len(ivs))
-	}
-	return total
-}
-
-// addInterval to an existing memTombstones
-func (t *memTombstones) addInterval(ref uint64, itvs ...Interval) {
-	t.mtx.Lock()
-	defer t.mtx.Unlock()
-	for _, itv := range itvs {
-		t.intvlGroups[ref] = t.intvlGroups[ref].add(itv)
-	}
-}
-
-func (*memTombstones) Close() error {
-	return nil
-}
-
-// Interval represents a single time-interval.
-type Interval struct {
-	Mint, Maxt int64
-}
-
-func (tr Interval) inBounds(t int64) bool {
-	return t >= tr.Mint && t <= tr.Maxt
-}
-
-func (tr Interval) isSubrange(dranges Intervals) bool {
-	for _, r := range dranges {
-		if r.inBounds(tr.Mint) && r.inBounds(tr.Maxt) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// Intervals represents	a set of increasing and non-overlapping time-intervals.
-type Intervals []Interval
-
-// add the new time-range to the existing ones.
-// The existing ones must be sorted.
-func (itvs Intervals) add(n Interval) Intervals {
-	for i, r := range itvs {
-		// TODO(gouthamve): Make this codepath easier to digest.
-		if r.inBounds(n.Mint-1) || r.inBounds(n.Mint) {
-			if n.Maxt > r.Maxt {
-				itvs[i].Maxt = n.Maxt
-			}
-
-			j := 0
-			for _, r2 := range itvs[i+1:] {
-				if n.Maxt < r2.Mint {
-					break
-				}
-				j++
-			}
-			if j != 0 {
-				if itvs[i+j].Maxt > n.Maxt {
-					itvs[i].Maxt = itvs[i+j].Maxt
-				}
-				itvs = append(itvs[:i+1], itvs[i+j+1:]...)
-			}
-			return itvs
-		}
-
-		if r.inBounds(n.Maxt+1) || r.inBounds(n.Maxt) {
-			if n.Mint < r.Maxt {
-				itvs[i].Mint = n.Mint
-			}
-			return itvs
-		}
-
-		if n.Mint < r.Mint {
-			newRange := make(Intervals, i, len(itvs[:i])+1)
-			copy(newRange, itvs[:i])
-			newRange = append(newRange, n)
-			newRange = append(newRange, itvs[i:]...)
-
-			return newRange
-		}
-	}
-
-	itvs = append(itvs, n)
-	return itvs
-}
diff --git a/vendor/github.com/prometheus/tsdb/wal.go b/vendor/github.com/prometheus/tsdb/wal.go
deleted file mode 100644
index 49f55fe404..0000000000
--- a/vendor/github.com/prometheus/tsdb/wal.go
+++ /dev/null
@@ -1,1313 +0,0 @@
-// Copyright 2017 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.
-
-package tsdb
-
-import (
-	"bufio"
-	"encoding/binary"
-	"fmt"
-	"hash"
-	"hash/crc32"
-	"io"
-	"math"
-	"os"
-	"path/filepath"
-	"sort"
-	"sync"
-	"time"
-
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
-	"github.com/pkg/errors"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/tsdb/encoding"
-	"github.com/prometheus/tsdb/fileutil"
-	"github.com/prometheus/tsdb/labels"
-	"github.com/prometheus/tsdb/wal"
-)
-
-// WALEntryType indicates what data a WAL entry contains.
-type WALEntryType uint8
-
-const (
-	// WALMagic is a 4 byte number every WAL segment file starts with.
-	WALMagic = uint32(0x43AF00EF)
-
-	// WALFormatDefault is the version flag for the default outer segment file format.
-	WALFormatDefault = byte(1)
-)
-
-// Entry types in a segment file.
-const (
-	WALEntrySymbols WALEntryType = 1
-	WALEntrySeries  WALEntryType = 2
-	WALEntrySamples WALEntryType = 3
-	WALEntryDeletes WALEntryType = 4
-)
-
-type walMetrics struct {
-	fsyncDuration prometheus.Summary
-	corruptions   prometheus.Counter
-}
-
-func newWalMetrics(wal *SegmentWAL, r prometheus.Registerer) *walMetrics {
-	m := &walMetrics{}
-
-	m.fsyncDuration = prometheus.NewSummary(prometheus.SummaryOpts{
-		Name:       "prometheus_tsdb_wal_fsync_duration_seconds",
-		Help:       "Duration of WAL fsync.",
-		Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
-	})
-	m.corruptions = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_wal_corruptions_total",
-		Help: "Total number of WAL corruptions.",
-	})
-
-	if r != nil {
-		r.MustRegister(
-			m.fsyncDuration,
-			m.corruptions,
-		)
-	}
-	return m
-}
-
-// WAL is a write ahead log that can log new series labels and samples.
-// It must be completely read before new entries are logged.
-//
-// DEPRECATED: use wal pkg combined with the record codex instead.
-type WAL interface {
-	Reader() WALReader
-	LogSeries([]RefSeries) error
-	LogSamples([]RefSample) error
-	LogDeletes([]Stone) error
-	Truncate(mint int64, keep func(uint64) bool) error
-	Close() error
-}
-
-// WALReader reads entries from a WAL.
-type WALReader interface {
-	Read(
-		seriesf func([]RefSeries),
-		samplesf func([]RefSample),
-		deletesf func([]Stone),
-	) error
-}
-
-// RefSeries is the series labels with the series ID.
-type RefSeries struct {
-	Ref    uint64
-	Labels labels.Labels
-}
-
-// RefSample is a timestamp/value pair associated with a reference to a series.
-type RefSample struct {
-	Ref uint64
-	T   int64
-	V   float64
-
-	series *memSeries
-}
-
-// segmentFile wraps a file object of a segment and tracks the highest timestamp
-// it contains. During WAL truncating, all segments with no higher timestamp than
-// the truncation threshold can be compacted.
-type segmentFile struct {
-	*os.File
-	maxTime   int64  // highest tombstone or sample timpstamp in segment
-	minSeries uint64 // lowerst series ID in segment
-}
-
-func newSegmentFile(f *os.File) *segmentFile {
-	return &segmentFile{
-		File:      f,
-		maxTime:   math.MinInt64,
-		minSeries: math.MaxUint64,
-	}
-}
-
-const (
-	walSegmentSizeBytes = 256 * 1024 * 1024 // 256 MB
-)
-
-// The table gets initialized with sync.Once but may still cause a race
-// with any other use of the crc32 package anywhere. Thus we initialize it
-// before.
-var castagnoliTable *crc32.Table
-
-func init() {
-	castagnoliTable = crc32.MakeTable(crc32.Castagnoli)
-}
-
-// newCRC32 initializes a CRC32 hash with a preconfigured polynomial, so the
-// polynomial may be easily changed in one location at a later time, if necessary.
-func newCRC32() hash.Hash32 {
-	return crc32.New(castagnoliTable)
-}
-
-// SegmentWAL is a write ahead log for series data.
-//
-// DEPRECATED: use wal pkg combined with the record coders instead.
-type SegmentWAL struct {
-	mtx     sync.Mutex
-	metrics *walMetrics
-
-	dirFile *os.File
-	files   []*segmentFile
-
-	logger        log.Logger
-	flushInterval time.Duration
-	segmentSize   int64
-
-	crc32 hash.Hash32
-	cur   *bufio.Writer
-	curN  int64
-
-	stopc   chan struct{}
-	donec   chan struct{}
-	actorc  chan func() error // sequentialized background operations
-	buffers sync.Pool
-}
-
-// OpenSegmentWAL opens or creates a write ahead log in the given directory.
-// The WAL must be read completely before new data is written.
-func OpenSegmentWAL(dir string, logger log.Logger, flushInterval time.Duration, r prometheus.Registerer) (*SegmentWAL, error) {
-	if err := os.MkdirAll(dir, 0777); err != nil {
-		return nil, err
-	}
-	df, err := fileutil.OpenDir(dir)
-	if err != nil {
-		return nil, err
-	}
-	if logger == nil {
-		logger = log.NewNopLogger()
-	}
-
-	w := &SegmentWAL{
-		dirFile:       df,
-		logger:        logger,
-		flushInterval: flushInterval,
-		donec:         make(chan struct{}),
-		stopc:         make(chan struct{}),
-		actorc:        make(chan func() error, 1),
-		segmentSize:   walSegmentSizeBytes,
-		crc32:         newCRC32(),
-	}
-	w.metrics = newWalMetrics(w, r)
-
-	fns, err := sequenceFiles(w.dirFile.Name())
-	if err != nil {
-		return nil, err
-	}
-
-	for i, fn := range fns {
-		f, err := w.openSegmentFile(fn)
-		if err == nil {
-			w.files = append(w.files, newSegmentFile(f))
-			continue
-		}
-		level.Warn(logger).Log("msg", "invalid segment file detected, truncating WAL", "err", err, "file", fn)
-
-		for _, fn := range fns[i:] {
-			if err := os.Remove(fn); err != nil {
-				return w, errors.Wrap(err, "removing segment failed")
-			}
-		}
-		break
-	}
-
-	go w.run(flushInterval)
-
-	return w, nil
-}
-
-// repairingWALReader wraps a WAL reader and truncates its underlying SegmentWAL after the last
-// valid entry if it encounters corruption.
-type repairingWALReader struct {
-	wal *SegmentWAL
-	r   WALReader
-}
-
-func (r *repairingWALReader) Read(
-	seriesf func([]RefSeries),
-	samplesf func([]RefSample),
-	deletesf func([]Stone),
-) error {
-	err := r.r.Read(seriesf, samplesf, deletesf)
-	if err == nil {
-		return nil
-	}
-	cerr, ok := errors.Cause(err).(walCorruptionErr)
-	if !ok {
-		return err
-	}
-	r.wal.metrics.corruptions.Inc()
-	return r.wal.truncate(cerr.err, cerr.file, cerr.lastOffset)
-}
-
-// truncate the WAL after the last valid entry.
-func (w *SegmentWAL) truncate(err error, file int, lastOffset int64) error {
-	level.Error(w.logger).Log("msg", "WAL corruption detected; truncating",
-		"err", err, "file", w.files[file].Name(), "pos", lastOffset)
-
-	// Close and delete all files after the current one.
-	for _, f := range w.files[file+1:] {
-		if err := f.Close(); err != nil {
-			return err
-		}
-		if err := os.Remove(f.Name()); err != nil {
-			return err
-		}
-	}
-	w.mtx.Lock()
-	defer w.mtx.Unlock()
-
-	w.files = w.files[:file+1]
-
-	// Seek the current file to the last valid offset where we continue writing from.
-	_, err = w.files[file].Seek(lastOffset, io.SeekStart)
-	return err
-}
-
-// Reader returns a new reader over the the write ahead log data.
-// It must be completely consumed before writing to the WAL.
-func (w *SegmentWAL) Reader() WALReader {
-	return &repairingWALReader{
-		wal: w,
-		r:   newWALReader(w.files, w.logger),
-	}
-}
-
-func (w *SegmentWAL) getBuffer() *encoding.Encbuf {
-	b := w.buffers.Get()
-	if b == nil {
-		return &encoding.Encbuf{B: make([]byte, 0, 64*1024)}
-	}
-	return b.(*encoding.Encbuf)
-}
-
-func (w *SegmentWAL) putBuffer(b *encoding.Encbuf) {
-	b.Reset()
-	w.buffers.Put(b)
-}
-
-// Truncate deletes the values prior to mint and the series which the keep function
-// does not indicate to preserve.
-func (w *SegmentWAL) Truncate(mint int64, keep func(uint64) bool) error {
-	// The last segment is always active.
-	if len(w.files) < 2 {
-		return nil
-	}
-	var candidates []*segmentFile
-
-	// All files have to be traversed as there could be two segments for a block
-	// with first block having times (10000, 20000) and SECOND one having (0, 10000).
-	for _, sf := range w.files[:len(w.files)-1] {
-		if sf.maxTime >= mint {
-			break
-		}
-		// Past WAL files are closed. We have to reopen them for another read.
-		f, err := w.openSegmentFile(sf.Name())
-		if err != nil {
-			return errors.Wrap(err, "open old WAL segment for read")
-		}
-		candidates = append(candidates, &segmentFile{
-			File:      f,
-			minSeries: sf.minSeries,
-			maxTime:   sf.maxTime,
-		})
-	}
-	if len(candidates) == 0 {
-		return nil
-	}
-
-	r := newWALReader(candidates, w.logger)
-
-	// Create a new tmp file.
-	f, err := w.createSegmentFile(filepath.Join(w.dirFile.Name(), "compact.tmp"))
-	if err != nil {
-		return errors.Wrap(err, "create compaction segment")
-	}
-	defer func() {
-		if err := os.RemoveAll(f.Name()); err != nil {
-			level.Error(w.logger).Log("msg", "remove tmp file", "err", err.Error())
-		}
-	}()
-
-	var (
-		csf          = newSegmentFile(f)
-		crc32        = newCRC32()
-		decSeries    = []RefSeries{}
-		activeSeries = []RefSeries{}
-	)
-
-	for r.next() {
-		rt, flag, byt := r.at()
-
-		if rt != WALEntrySeries {
-			continue
-		}
-		decSeries = decSeries[:0]
-		activeSeries = activeSeries[:0]
-
-		err := r.decodeSeries(flag, byt, &decSeries)
-		if err != nil {
-			return errors.Wrap(err, "decode samples while truncating")
-		}
-		for _, s := range decSeries {
-			if keep(s.Ref) {
-				activeSeries = append(activeSeries, s)
-			}
-		}
-
-		buf := w.getBuffer()
-		flag = w.encodeSeries(buf, activeSeries)
-
-		_, err = w.writeTo(csf, crc32, WALEntrySeries, flag, buf.Get())
-		w.putBuffer(buf)
-
-		if err != nil {
-			return errors.Wrap(err, "write to compaction segment")
-		}
-	}
-	if r.Err() != nil {
-		return errors.Wrap(r.Err(), "read candidate WAL files")
-	}
-
-	off, err := csf.Seek(0, io.SeekCurrent)
-	if err != nil {
-		return err
-	}
-	if err := csf.Truncate(off); err != nil {
-		return err
-	}
-	csf.Sync()
-	csf.Close()
-
-	candidates[0].Close() // need close before remove on platform windows
-	if err := fileutil.Replace(csf.Name(), candidates[0].Name()); err != nil {
-		return errors.Wrap(err, "rename compaction segment")
-	}
-	for _, f := range candidates[1:] {
-		f.Close() // need close before remove on platform windows
-		if err := os.RemoveAll(f.Name()); err != nil {
-			return errors.Wrap(err, "delete WAL segment file")
-		}
-	}
-	if err := w.dirFile.Sync(); err != nil {
-		return err
-	}
-
-	// The file object of csf still holds the name before rename. Recreate it so
-	// subsequent truncations do not look at a non-existent file name.
-	csf.File, err = w.openSegmentFile(candidates[0].Name())
-	if err != nil {
-		return err
-	}
-	// We don't need it to be open.
-	csf.Close()
-
-	w.mtx.Lock()
-	w.files = append([]*segmentFile{csf}, w.files[len(candidates):]...)
-	w.mtx.Unlock()
-
-	return nil
-}
-
-// LogSeries writes a batch of new series labels to the log.
-// The series have to be ordered.
-func (w *SegmentWAL) LogSeries(series []RefSeries) error {
-	buf := w.getBuffer()
-
-	flag := w.encodeSeries(buf, series)
-
-	w.mtx.Lock()
-	defer w.mtx.Unlock()
-
-	err := w.write(WALEntrySeries, flag, buf.Get())
-
-	w.putBuffer(buf)
-
-	if err != nil {
-		return errors.Wrap(err, "log series")
-	}
-
-	tf := w.head()
-
-	for _, s := range series {
-		if tf.minSeries > s.Ref {
-			tf.minSeries = s.Ref
-		}
-	}
-	return nil
-}
-
-// LogSamples writes a batch of new samples to the log.
-func (w *SegmentWAL) LogSamples(samples []RefSample) error {
-	buf := w.getBuffer()
-
-	flag := w.encodeSamples(buf, samples)
-
-	w.mtx.Lock()
-	defer w.mtx.Unlock()
-
-	err := w.write(WALEntrySamples, flag, buf.Get())
-
-	w.putBuffer(buf)
-
-	if err != nil {
-		return errors.Wrap(err, "log series")
-	}
-	tf := w.head()
-
-	for _, s := range samples {
-		if tf.maxTime < s.T {
-			tf.maxTime = s.T
-		}
-	}
-	return nil
-}
-
-// LogDeletes write a batch of new deletes to the log.
-func (w *SegmentWAL) LogDeletes(stones []Stone) error {
-	buf := w.getBuffer()
-
-	flag := w.encodeDeletes(buf, stones)
-
-	w.mtx.Lock()
-	defer w.mtx.Unlock()
-
-	err := w.write(WALEntryDeletes, flag, buf.Get())
-
-	w.putBuffer(buf)
-
-	if err != nil {
-		return errors.Wrap(err, "log series")
-	}
-	tf := w.head()
-
-	for _, s := range stones {
-		for _, iv := range s.intervals {
-			if tf.maxTime < iv.Maxt {
-				tf.maxTime = iv.Maxt
-			}
-		}
-	}
-	return nil
-}
-
-// openSegmentFile opens the given segment file and consumes and validates header.
-func (w *SegmentWAL) openSegmentFile(name string) (*os.File, error) {
-	// We must open all files in read/write mode as we may have to truncate along
-	// the way and any file may become the head.
-	f, err := os.OpenFile(name, os.O_RDWR, 0666)
-	if err != nil {
-		return nil, err
-	}
-	metab := make([]byte, 8)
-
-	// If there is an error, we need close f for platform windows before gc.
-	// Otherwise, file op may fail.
-	hasError := true
-	defer func() {
-		if hasError {
-			f.Close()
-		}
-	}()
-
-	if n, err := f.Read(metab); err != nil {
-		return nil, errors.Wrapf(err, "validate meta %q", f.Name())
-	} else if n != 8 {
-		return nil, errors.Errorf("invalid header size %d in %q", n, f.Name())
-	}
-
-	if m := binary.BigEndian.Uint32(metab[:4]); m != WALMagic {
-		return nil, errors.Errorf("invalid magic header %x in %q", m, f.Name())
-	}
-	if metab[4] != WALFormatDefault {
-		return nil, errors.Errorf("unknown WAL segment format %d in %q", metab[4], f.Name())
-	}
-	hasError = false
-	return f, nil
-}
-
-// createSegmentFile creates a new segment file with the given name. It preallocates
-// the standard segment size if possible and writes the header.
-func (w *SegmentWAL) createSegmentFile(name string) (*os.File, error) {
-	f, err := os.Create(name)
-	if err != nil {
-		return nil, err
-	}
-	if err = fileutil.Preallocate(f, w.segmentSize, true); err != nil {
-		return nil, err
-	}
-	// Write header metadata for new file.
-	metab := make([]byte, 8)
-	binary.BigEndian.PutUint32(metab[:4], WALMagic)
-	metab[4] = WALFormatDefault
-
-	if _, err := f.Write(metab); err != nil {
-		return nil, err
-	}
-	return f, err
-}
-
-// cut finishes the currently active segments and opens the next one.
-// The encoder is reset to point to the new segment.
-func (w *SegmentWAL) cut() error {
-	// Sync current head to disk and close.
-	if hf := w.head(); hf != nil {
-		if err := w.flush(); err != nil {
-			return err
-		}
-		// Finish last segment asynchronously to not block the WAL moving along
-		// in the new segment.
-		go func() {
-			w.actorc <- func() error {
-				off, err := hf.Seek(0, io.SeekCurrent)
-				if err != nil {
-					return errors.Wrapf(err, "finish old segment %s", hf.Name())
-				}
-				if err := hf.Truncate(off); err != nil {
-					return errors.Wrapf(err, "finish old segment %s", hf.Name())
-				}
-				if err := hf.Sync(); err != nil {
-					return errors.Wrapf(err, "finish old segment %s", hf.Name())
-				}
-				if err := hf.Close(); err != nil {
-					return errors.Wrapf(err, "finish old segment %s", hf.Name())
-				}
-				return nil
-			}
-		}()
-	}
-
-	p, _, err := nextSequenceFile(w.dirFile.Name())
-	if err != nil {
-		return err
-	}
-	f, err := w.createSegmentFile(p)
-	if err != nil {
-		return err
-	}
-
-	go func() {
-		w.actorc <- func() error {
-			return errors.Wrap(w.dirFile.Sync(), "sync WAL directory")
-		}
-	}()
-
-	w.files = append(w.files, newSegmentFile(f))
-
-	// TODO(gouthamve): make the buffer size a constant.
-	w.cur = bufio.NewWriterSize(f, 8*1024*1024)
-	w.curN = 8
-
-	return nil
-}
-
-func (w *SegmentWAL) head() *segmentFile {
-	if len(w.files) == 0 {
-		return nil
-	}
-	return w.files[len(w.files)-1]
-}
-
-// Sync flushes the changes to disk.
-func (w *SegmentWAL) Sync() error {
-	var head *segmentFile
-	var err error
-
-	// Flush the writer and retrieve the reference to the head segment under mutex lock.
-	func() {
-		w.mtx.Lock()
-		defer w.mtx.Unlock()
-		if err = w.flush(); err != nil {
-			return
-		}
-		head = w.head()
-	}()
-	if err != nil {
-		return errors.Wrap(err, "flush buffer")
-	}
-	if head != nil {
-		// But only fsync the head segment after releasing the mutex as it will block on disk I/O.
-		start := time.Now()
-		err := fileutil.Fdatasync(head.File)
-		w.metrics.fsyncDuration.Observe(time.Since(start).Seconds())
-		return err
-	}
-	return nil
-}
-
-func (w *SegmentWAL) sync() error {
-	if err := w.flush(); err != nil {
-		return err
-	}
-	if w.head() == nil {
-		return nil
-	}
-
-	start := time.Now()
-	err := fileutil.Fdatasync(w.head().File)
-	w.metrics.fsyncDuration.Observe(time.Since(start).Seconds())
-	return err
-}
-
-func (w *SegmentWAL) flush() error {
-	if w.cur == nil {
-		return nil
-	}
-	return w.cur.Flush()
-}
-
-func (w *SegmentWAL) run(interval time.Duration) {
-	var tick <-chan time.Time
-
-	if interval > 0 {
-		ticker := time.NewTicker(interval)
-		defer ticker.Stop()
-		tick = ticker.C
-	}
-	defer close(w.donec)
-
-	for {
-		// Processing all enqueued operations has precedence over shutdown and
-		// background syncs.
-		select {
-		case f := <-w.actorc:
-			if err := f(); err != nil {
-				level.Error(w.logger).Log("msg", "operation failed", "err", err)
-			}
-			continue
-		default:
-		}
-		select {
-		case <-w.stopc:
-			return
-		case f := <-w.actorc:
-			if err := f(); err != nil {
-				level.Error(w.logger).Log("msg", "operation failed", "err", err)
-			}
-		case <-tick:
-			if err := w.Sync(); err != nil {
-				level.Error(w.logger).Log("msg", "sync failed", "err", err)
-			}
-		}
-	}
-}
-
-// Close syncs all data and closes the underlying resources.
-func (w *SegmentWAL) Close() error {
-	// Make sure you can call Close() multiple times.
-	select {
-	case <-w.stopc:
-		return nil // Already closed.
-	default:
-	}
-
-	close(w.stopc)
-	<-w.donec
-
-	w.mtx.Lock()
-	defer w.mtx.Unlock()
-
-	if err := w.sync(); err != nil {
-		return err
-	}
-	// On opening, a WAL must be fully consumed once. Afterwards
-	// only the current segment will still be open.
-	if hf := w.head(); hf != nil {
-		if err := hf.Close(); err != nil {
-			return errors.Wrapf(err, "closing WAL head %s", hf.Name())
-		}
-	}
-
-	return errors.Wrapf(w.dirFile.Close(), "closing WAL dir %s", w.dirFile.Name())
-}
-
-func (w *SegmentWAL) write(t WALEntryType, flag uint8, buf []byte) error {
-	// Cut to the next segment if the entry exceeds the file size unless it would also
-	// exceed the size of a new segment.
-	// TODO(gouthamve): Add a test for this case where the commit is greater than segmentSize.
-	var (
-		sz    = int64(len(buf)) + 6
-		newsz = w.curN + sz
-	)
-	// XXX(fabxc): this currently cuts a new file whenever the WAL was newly opened.
-	// Probably fine in general but may yield a lot of short files in some cases.
-	if w.cur == nil || w.curN > w.segmentSize || newsz > w.segmentSize && sz <= w.segmentSize {
-		if err := w.cut(); err != nil {
-			return err
-		}
-	}
-	n, err := w.writeTo(w.cur, w.crc32, t, flag, buf)
-
-	w.curN += int64(n)
-
-	return err
-}
-
-func (w *SegmentWAL) writeTo(wr io.Writer, crc32 hash.Hash, t WALEntryType, flag uint8, buf []byte) (int, error) {
-	if len(buf) == 0 {
-		return 0, nil
-	}
-	crc32.Reset()
-	wr = io.MultiWriter(crc32, wr)
-
-	var b [6]byte
-	b[0] = byte(t)
-	b[1] = flag
-
-	binary.BigEndian.PutUint32(b[2:], uint32(len(buf)))
-
-	n1, err := wr.Write(b[:])
-	if err != nil {
-		return n1, err
-	}
-	n2, err := wr.Write(buf)
-	if err != nil {
-		return n1 + n2, err
-	}
-	n3, err := wr.Write(crc32.Sum(b[:0]))
-
-	return n1 + n2 + n3, err
-}
-
-const (
-	walSeriesSimple  = 1
-	walSamplesSimple = 1
-	walDeletesSimple = 1
-)
-
-func (w *SegmentWAL) encodeSeries(buf *encoding.Encbuf, series []RefSeries) uint8 {
-	for _, s := range series {
-		buf.PutBE64(s.Ref)
-		buf.PutUvarint(len(s.Labels))
-
-		for _, l := range s.Labels {
-			buf.PutUvarintStr(l.Name)
-			buf.PutUvarintStr(l.Value)
-		}
-	}
-	return walSeriesSimple
-}
-
-func (w *SegmentWAL) encodeSamples(buf *encoding.Encbuf, samples []RefSample) uint8 {
-	if len(samples) == 0 {
-		return walSamplesSimple
-	}
-	// Store base timestamp and base reference number of first sample.
-	// All samples encode their timestamp and ref as delta to those.
-	//
-	// TODO(fabxc): optimize for all samples having the same timestamp.
-	first := samples[0]
-
-	buf.PutBE64(first.Ref)
-	buf.PutBE64int64(first.T)
-
-	for _, s := range samples {
-		buf.PutVarint64(int64(s.Ref) - int64(first.Ref))
-		buf.PutVarint64(s.T - first.T)
-		buf.PutBE64(math.Float64bits(s.V))
-	}
-	return walSamplesSimple
-}
-
-func (w *SegmentWAL) encodeDeletes(buf *encoding.Encbuf, stones []Stone) uint8 {
-	for _, s := range stones {
-		for _, iv := range s.intervals {
-			buf.PutBE64(s.ref)
-			buf.PutVarint64(iv.Mint)
-			buf.PutVarint64(iv.Maxt)
-		}
-	}
-	return walDeletesSimple
-}
-
-// walReader decodes and emits write ahead log entries.
-type walReader struct {
-	logger log.Logger
-
-	files []*segmentFile
-	cur   int
-	buf   []byte
-	crc32 hash.Hash32
-
-	curType    WALEntryType
-	curFlag    byte
-	curBuf     []byte
-	lastOffset int64 // offset after last successfully read entry
-
-	err error
-}
-
-func newWALReader(files []*segmentFile, l log.Logger) *walReader {
-	if l == nil {
-		l = log.NewNopLogger()
-	}
-	return &walReader{
-		logger: l,
-		files:  files,
-		buf:    make([]byte, 0, 128*4096),
-		crc32:  newCRC32(),
-	}
-}
-
-// Err returns the last error the reader encountered.
-func (r *walReader) Err() error {
-	return r.err
-}
-
-func (r *walReader) Read(
-	seriesf func([]RefSeries),
-	samplesf func([]RefSample),
-	deletesf func([]Stone),
-) error {
-	// Concurrency for replaying the WAL is very limited. We at least split out decoding and
-	// processing into separate threads.
-	// Historically, the processing is the bottleneck with reading and decoding using only
-	// 15% of the CPU.
-	var (
-		seriesPool sync.Pool
-		samplePool sync.Pool
-		deletePool sync.Pool
-	)
-	donec := make(chan struct{})
-	datac := make(chan interface{}, 100)
-
-	go func() {
-		defer close(donec)
-
-		for x := range datac {
-			switch v := x.(type) {
-			case []RefSeries:
-				if seriesf != nil {
-					seriesf(v)
-				}
-				//lint:ignore SA6002 safe to ignore and actually fixing it has some performance penalty.
-				seriesPool.Put(v[:0])
-			case []RefSample:
-				if samplesf != nil {
-					samplesf(v)
-				}
-				//lint:ignore SA6002 safe to ignore and actually fixing it has some performance penalty.
-				samplePool.Put(v[:0])
-			case []Stone:
-				if deletesf != nil {
-					deletesf(v)
-				}
-				//lint:ignore SA6002 safe to ignore and actually fixing it has some performance penalty.
-				deletePool.Put(v[:0])
-			default:
-				level.Error(r.logger).Log("msg", "unexpected data type")
-			}
-		}
-	}()
-
-	var err error
-
-	for r.next() {
-		et, flag, b := r.at()
-
-		// In decoding below we never return a walCorruptionErr for now.
-		// Those should generally be catched by entry decoding before.
-		switch et {
-		case WALEntrySeries:
-			var series []RefSeries
-			if v := seriesPool.Get(); v == nil {
-				series = make([]RefSeries, 0, 512)
-			} else {
-				series = v.([]RefSeries)
-			}
-
-			err = r.decodeSeries(flag, b, &series)
-			if err != nil {
-				err = errors.Wrap(err, "decode series entry")
-				break
-			}
-			datac <- series
-
-			cf := r.current()
-			for _, s := range series {
-				if cf.minSeries > s.Ref {
-					cf.minSeries = s.Ref
-				}
-			}
-		case WALEntrySamples:
-			var samples []RefSample
-			if v := samplePool.Get(); v == nil {
-				samples = make([]RefSample, 0, 512)
-			} else {
-				samples = v.([]RefSample)
-			}
-
-			err = r.decodeSamples(flag, b, &samples)
-			if err != nil {
-				err = errors.Wrap(err, "decode samples entry")
-				break
-			}
-			datac <- samples
-
-			// Update the times for the WAL segment file.
-			cf := r.current()
-			for _, s := range samples {
-				if cf.maxTime < s.T {
-					cf.maxTime = s.T
-				}
-			}
-		case WALEntryDeletes:
-			var deletes []Stone
-			if v := deletePool.Get(); v == nil {
-				deletes = make([]Stone, 0, 512)
-			} else {
-				deletes = v.([]Stone)
-			}
-
-			err = r.decodeDeletes(flag, b, &deletes)
-			if err != nil {
-				err = errors.Wrap(err, "decode delete entry")
-				break
-			}
-			datac <- deletes
-
-			// Update the times for the WAL segment file.
-			cf := r.current()
-			for _, s := range deletes {
-				for _, iv := range s.intervals {
-					if cf.maxTime < iv.Maxt {
-						cf.maxTime = iv.Maxt
-					}
-				}
-			}
-		}
-	}
-	close(datac)
-	<-donec
-
-	if err != nil {
-		return err
-	}
-	if r.Err() != nil {
-		return errors.Wrap(r.Err(), "read entry")
-	}
-	return nil
-}
-
-func (r *walReader) at() (WALEntryType, byte, []byte) {
-	return r.curType, r.curFlag, r.curBuf
-}
-
-// next returns decodes the next entry pair and returns true
-// if it was successful.
-func (r *walReader) next() bool {
-	if r.cur >= len(r.files) {
-		return false
-	}
-	cf := r.files[r.cur]
-
-	// Remember the offset after the last correctly read entry. If the next one
-	// is corrupted, this is where we can safely truncate.
-	r.lastOffset, r.err = cf.Seek(0, io.SeekCurrent)
-	if r.err != nil {
-		return false
-	}
-
-	et, flag, b, err := r.entry(cf)
-	// If we reached the end of the reader, advance to the next one
-	// and close.
-	// Do not close on the last one as it will still be appended to.
-	if err == io.EOF {
-		if r.cur == len(r.files)-1 {
-			return false
-		}
-		// Current reader completed, close and move to the next one.
-		if err := cf.Close(); err != nil {
-			r.err = err
-			return false
-		}
-		r.cur++
-		return r.next()
-	}
-	if err != nil {
-		r.err = err
-		return false
-	}
-
-	r.curType = et
-	r.curFlag = flag
-	r.curBuf = b
-	return r.err == nil
-}
-
-func (r *walReader) current() *segmentFile {
-	return r.files[r.cur]
-}
-
-// walCorruptionErr is a type wrapper for errors that indicate WAL corruption
-// and trigger a truncation.
-type walCorruptionErr struct {
-	err        error
-	file       int
-	lastOffset int64
-}
-
-func (e walCorruptionErr) Error() string {
-	return fmt.Sprintf("%s <file: %d, lastOffset: %d>", e.err, e.file, e.lastOffset)
-}
-
-func (r *walReader) corruptionErr(s string, args ...interface{}) error {
-	return walCorruptionErr{
-		err:        errors.Errorf(s, args...),
-		file:       r.cur,
-		lastOffset: r.lastOffset,
-	}
-}
-
-func (r *walReader) entry(cr io.Reader) (WALEntryType, byte, []byte, error) {
-	r.crc32.Reset()
-	tr := io.TeeReader(cr, r.crc32)
-
-	b := make([]byte, 6)
-	if n, err := tr.Read(b); err != nil {
-		return 0, 0, nil, err
-	} else if n != 6 {
-		return 0, 0, nil, r.corruptionErr("invalid entry header size %d", n)
-	}
-
-	var (
-		etype  = WALEntryType(b[0])
-		flag   = b[1]
-		length = int(binary.BigEndian.Uint32(b[2:]))
-	)
-	// Exit if we reached pre-allocated space.
-	if etype == 0 {
-		return 0, 0, nil, io.EOF
-	}
-	if etype != WALEntrySeries && etype != WALEntrySamples && etype != WALEntryDeletes {
-		return 0, 0, nil, r.corruptionErr("invalid entry type %d", etype)
-	}
-
-	if length > len(r.buf) {
-		r.buf = make([]byte, length)
-	}
-	buf := r.buf[:length]
-
-	if n, err := tr.Read(buf); err != nil {
-		return 0, 0, nil, err
-	} else if n != length {
-		return 0, 0, nil, r.corruptionErr("invalid entry body size %d", n)
-	}
-
-	if n, err := cr.Read(b[:4]); err != nil {
-		return 0, 0, nil, err
-	} else if n != 4 {
-		return 0, 0, nil, r.corruptionErr("invalid checksum length %d", n)
-	}
-	if exp, has := binary.BigEndian.Uint32(b[:4]), r.crc32.Sum32(); has != exp {
-		return 0, 0, nil, r.corruptionErr("unexpected CRC32 checksum %x, want %x", has, exp)
-	}
-
-	return etype, flag, buf, nil
-}
-
-func (r *walReader) decodeSeries(flag byte, b []byte, res *[]RefSeries) error {
-	dec := encoding.Decbuf{B: b}
-
-	for len(dec.B) > 0 && dec.Err() == nil {
-		ref := dec.Be64()
-
-		lset := make(labels.Labels, dec.Uvarint())
-
-		for i := range lset {
-			lset[i].Name = dec.UvarintStr()
-			lset[i].Value = dec.UvarintStr()
-		}
-		sort.Sort(lset)
-
-		*res = append(*res, RefSeries{
-			Ref:    ref,
-			Labels: lset,
-		})
-	}
-	if dec.Err() != nil {
-		return dec.Err()
-	}
-	if len(dec.B) > 0 {
-		return errors.Errorf("unexpected %d bytes left in entry", len(dec.B))
-	}
-	return nil
-}
-
-func (r *walReader) decodeSamples(flag byte, b []byte, res *[]RefSample) error {
-	if len(b) == 0 {
-		return nil
-	}
-	dec := encoding.Decbuf{B: b}
-
-	var (
-		baseRef  = dec.Be64()
-		baseTime = dec.Be64int64()
-	)
-
-	for len(dec.B) > 0 && dec.Err() == nil {
-		dref := dec.Varint64()
-		dtime := dec.Varint64()
-		val := dec.Be64()
-
-		*res = append(*res, RefSample{
-			Ref: uint64(int64(baseRef) + dref),
-			T:   baseTime + dtime,
-			V:   math.Float64frombits(val),
-		})
-	}
-
-	if dec.Err() != nil {
-		return errors.Wrapf(dec.Err(), "decode error after %d samples", len(*res))
-	}
-	if len(dec.B) > 0 {
-		return errors.Errorf("unexpected %d bytes left in entry", len(dec.B))
-	}
-	return nil
-}
-
-func (r *walReader) decodeDeletes(flag byte, b []byte, res *[]Stone) error {
-	dec := &encoding.Decbuf{B: b}
-
-	for dec.Len() > 0 && dec.Err() == nil {
-		*res = append(*res, Stone{
-			ref: dec.Be64(),
-			intervals: Intervals{
-				{Mint: dec.Varint64(), Maxt: dec.Varint64()},
-			},
-		})
-	}
-	if dec.Err() != nil {
-		return dec.Err()
-	}
-	if len(dec.B) > 0 {
-		return errors.Errorf("unexpected %d bytes left in entry", len(dec.B))
-	}
-	return nil
-}
-
-func deprecatedWALExists(logger log.Logger, dir string) (bool, error) {
-	// Detect whether we still have the old WAL.
-	fns, err := sequenceFiles(dir)
-	if err != nil && !os.IsNotExist(err) {
-		return false, errors.Wrap(err, "list sequence files")
-	}
-	if len(fns) == 0 {
-		return false, nil // No WAL at all yet.
-	}
-	// Check header of first segment to see whether we are still dealing with an
-	// old WAL.
-	f, err := os.Open(fns[0])
-	if err != nil {
-		return false, errors.Wrap(err, "check first existing segment")
-	}
-	defer f.Close()
-
-	var hdr [4]byte
-	if _, err := f.Read(hdr[:]); err != nil && err != io.EOF {
-		return false, errors.Wrap(err, "read header from first segment")
-	}
-	// If we cannot read the magic header for segments of the old WAL, abort.
-	// Either it's migrated already or there's a corruption issue with which
-	// we cannot deal here anyway. Subsequent attempts to open the WAL will error in that case.
-	if binary.BigEndian.Uint32(hdr[:]) != WALMagic {
-		return false, nil
-	}
-	return true, nil
-}
-
-// MigrateWAL rewrites the deprecated write ahead log into the new format.
-func MigrateWAL(logger log.Logger, dir string) (err error) {
-	if logger == nil {
-		logger = log.NewNopLogger()
-	}
-	if exists, err := deprecatedWALExists(logger, dir); err != nil || !exists {
-		return err
-	}
-	level.Info(logger).Log("msg", "migrating WAL format")
-
-	tmpdir := dir + ".tmp"
-	if err := os.RemoveAll(tmpdir); err != nil {
-		return errors.Wrap(err, "cleanup replacement dir")
-	}
-	repl, err := wal.New(logger, nil, tmpdir, false)
-	if err != nil {
-		return errors.Wrap(err, "open new WAL")
-	}
-
-	// It should've already been closed as part of the previous finalization.
-	// Do it once again in case of prior errors.
-	defer func() {
-		if err != nil {
-			repl.Close()
-		}
-	}()
-
-	w, err := OpenSegmentWAL(dir, logger, time.Minute, nil)
-	if err != nil {
-		return errors.Wrap(err, "open old WAL")
-	}
-	defer w.Close()
-
-	rdr := w.Reader()
-
-	var (
-		enc RecordEncoder
-		b   []byte
-	)
-	decErr := rdr.Read(
-		func(s []RefSeries) {
-			if err != nil {
-				return
-			}
-			err = repl.Log(enc.Series(s, b[:0]))
-		},
-		func(s []RefSample) {
-			if err != nil {
-				return
-			}
-			err = repl.Log(enc.Samples(s, b[:0]))
-		},
-		func(s []Stone) {
-			if err != nil {
-				return
-			}
-			err = repl.Log(enc.Tombstones(s, b[:0]))
-		},
-	)
-	if decErr != nil {
-		return errors.Wrap(err, "decode old entries")
-	}
-	if err != nil {
-		return errors.Wrap(err, "write new entries")
-	}
-	// We explicitly close even when there is a defer for Windows to be
-	// able to delete it. The defer is in place to close it in-case there
-	// are errors above.
-	if err := w.Close(); err != nil {
-		return errors.Wrap(err, "close old WAL")
-	}
-	if err := repl.Close(); err != nil {
-		return errors.Wrap(err, "close new WAL")
-	}
-	if err := fileutil.Replace(tmpdir, dir); err != nil {
-		return errors.Wrap(err, "replace old WAL")
-	}
-	return nil
-}
diff --git a/vendor/github.com/prometheus/tsdb/wal/live_reader.go b/vendor/github.com/prometheus/tsdb/wal/live_reader.go
deleted file mode 100644
index 94175e7917..0000000000
--- a/vendor/github.com/prometheus/tsdb/wal/live_reader.go
+++ /dev/null
@@ -1,322 +0,0 @@
-// Copyright 2019 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.
-
-package wal
-
-import (
-	"encoding/binary"
-	"fmt"
-	"hash/crc32"
-	"io"
-
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
-	"github.com/golang/snappy"
-	"github.com/pkg/errors"
-	"github.com/prometheus/client_golang/prometheus"
-)
-
-// liveReaderMetrics holds all metrics exposed by the LiveReader.
-type liveReaderMetrics struct {
-	readerCorruptionErrors *prometheus.CounterVec
-}
-
-// LiveReaderMetrics instatiates, registers and returns metrics to be injected
-// at LiveReader instantiation.
-func NewLiveReaderMetrics(reg prometheus.Registerer) *liveReaderMetrics {
-	m := &liveReaderMetrics{
-		readerCorruptionErrors: prometheus.NewCounterVec(prometheus.CounterOpts{
-			Name: "prometheus_tsdb_wal_reader_corruption_errors_total",
-			Help: "Errors encountered when reading the WAL.",
-		}, []string{"error"}),
-	}
-
-	if reg != nil {
-		reg.Register(m.readerCorruptionErrors)
-	}
-
-	return m
-}
-
-// NewLiveReader returns a new live reader.
-func NewLiveReader(logger log.Logger, metrics *liveReaderMetrics, r io.Reader) *LiveReader {
-	lr := &LiveReader{
-		logger:  logger,
-		rdr:     r,
-		metrics: metrics,
-
-		// Until we understand how they come about, make readers permissive
-		// to records spanning pages.
-		permissive: true,
-	}
-
-	return lr
-}
-
-// LiveReader reads WAL records from an io.Reader. It allows reading of WALs
-// that are still in the process of being written, and returns records as soon
-// as they can be read.
-type LiveReader struct {
-	logger     log.Logger
-	rdr        io.Reader
-	err        error
-	rec        []byte
-	snappyBuf  []byte
-	hdr        [recordHeaderSize]byte
-	buf        [pageSize]byte
-	readIndex  int   // Index in buf to start at for next read.
-	writeIndex int   // Index in buf to start at for next write.
-	total      int64 // Total bytes processed during reading in calls to Next().
-	index      int   // Used to track partial records, should be 0 at the start of every new record.
-
-	// For testing, we can treat EOF as a non-error.
-	eofNonErr bool
-
-	// We sometime see records span page boundaries.  Should never happen, but it
-	// does.  Until we track down why, set permissive to true to tolerate it.
-	// NB the non-ive Reader implementation allows for this.
-	permissive bool
-
-	metrics *liveReaderMetrics
-}
-
-// Err returns any errors encountered reading the WAL.  io.EOFs are not terminal
-// and Next can be tried again.  Non-EOFs are terminal, and the reader should
-// not be used again.  It is up to the user to decide when to stop trying should
-// io.EOF be returned.
-func (r *LiveReader) Err() error {
-	if r.eofNonErr && r.err == io.EOF {
-		return nil
-	}
-	return r.err
-}
-
-// Offset returns the number of bytes consumed from this segment.
-func (r *LiveReader) Offset() int64 {
-	return r.total
-}
-
-func (r *LiveReader) fillBuffer() (int, error) {
-	n, err := r.rdr.Read(r.buf[r.writeIndex:len(r.buf)])
-	r.writeIndex += n
-	return n, err
-}
-
-// Next returns true if Record() will contain a full record.
-// If Next returns false, you should always checked the contents of Error().
-// Return false guarantees there are no more records if the segment is closed
-// and not corrupt, otherwise if Err() == io.EOF you should try again when more
-// data has been written.
-func (r *LiveReader) Next() bool {
-	for {
-		// If buildRecord returns a non-EOF error, its game up - the segment is
-		// corrupt. If buildRecord returns an EOF, we try and read more in
-		// fillBuffer later on. If that fails to read anything (n=0 && err=EOF),
-		// we return  EOF and the user can try again later. If we have a full
-		// page, buildRecord is guaranteed to return a record or a non-EOF; it
-		// has checks the records fit in pages.
-		if ok, err := r.buildRecord(); ok {
-			return true
-		} else if err != nil && err != io.EOF {
-			r.err = err
-			return false
-		}
-
-		// If we've filled the page and not found a record, this
-		// means records have started to span pages.  Shouldn't happen
-		// but does and until we found out why, we need to deal with this.
-		if r.permissive && r.writeIndex == pageSize && r.readIndex > 0 {
-			copy(r.buf[:], r.buf[r.readIndex:])
-			r.writeIndex -= r.readIndex
-			r.readIndex = 0
-			continue
-		}
-
-		if r.readIndex == pageSize {
-			r.writeIndex = 0
-			r.readIndex = 0
-		}
-
-		if r.writeIndex != pageSize {
-			n, err := r.fillBuffer()
-			if n == 0 || (err != nil && err != io.EOF) {
-				r.err = err
-				return false
-			}
-		}
-	}
-}
-
-// Record returns the current record.
-// The returned byte slice is only valid until the next call to Next.
-func (r *LiveReader) Record() []byte {
-	return r.rec
-}
-
-// Rebuild a full record from potentially partial records. Returns false
-// if there was an error or if we weren't able to read a record for any reason.
-// Returns true if we read a full record. Any record data is appended to
-// LiveReader.rec
-func (r *LiveReader) buildRecord() (bool, error) {
-	for {
-		// Check that we have data in the internal buffer to read.
-		if r.writeIndex <= r.readIndex {
-			return false, nil
-		}
-
-		// Attempt to read a record, partial or otherwise.
-		temp, n, err := r.readRecord()
-		if err != nil {
-			return false, err
-		}
-
-		r.readIndex += n
-		r.total += int64(n)
-		if temp == nil {
-			return false, nil
-		}
-
-		rt := recTypeFromHeader(r.hdr[0])
-		if rt == recFirst || rt == recFull {
-			r.rec = r.rec[:0]
-			r.snappyBuf = r.snappyBuf[:0]
-		}
-
-		compressed := r.hdr[0]&snappyMask != 0
-		if compressed {
-			r.snappyBuf = append(r.snappyBuf, temp...)
-		} else {
-			r.rec = append(r.rec, temp...)
-		}
-
-		if err := validateRecord(rt, r.index); err != nil {
-			r.index = 0
-			return false, err
-		}
-		if rt == recLast || rt == recFull {
-			r.index = 0
-			if compressed && len(r.snappyBuf) > 0 {
-				// The snappy library uses `len` to calculate if we need a new buffer.
-				// In order to allocate as few buffers as possible make the length
-				// equal to the capacity.
-				r.rec = r.rec[:cap(r.rec)]
-				r.rec, err = snappy.Decode(r.rec, r.snappyBuf)
-				if err != nil {
-					return false, err
-				}
-			}
-			return true, nil
-		}
-		// Only increment i for non-zero records since we use it
-		// to determine valid content record sequences.
-		r.index++
-	}
-}
-
-// Returns an error if the recType and i indicate an invalid record sequence.
-// As an example, if i is > 0 because we've read some amount of a partial record
-// (recFirst, recMiddle, etc. but not recLast) and then we get another recFirst or recFull
-// instead of a recLast or recMiddle we would have an invalid record.
-func validateRecord(typ recType, i int) error {
-	switch typ {
-	case recFull:
-		if i != 0 {
-			return errors.New("unexpected full record")
-		}
-		return nil
-	case recFirst:
-		if i != 0 {
-			return errors.New("unexpected first record, dropping buffer")
-		}
-		return nil
-	case recMiddle:
-		if i == 0 {
-			return errors.New("unexpected middle record, dropping buffer")
-		}
-		return nil
-	case recLast:
-		if i == 0 {
-			return errors.New("unexpected last record, dropping buffer")
-		}
-		return nil
-	default:
-		return errors.Errorf("unexpected record type %d", typ)
-	}
-}
-
-// Read a sub-record (see recType) from the buffer. It could potentially
-// be a full record (recFull) if the record fits within the bounds of a single page.
-// Returns a byte slice of the record data read, the number of bytes read, and an error
-// if there's a non-zero byte in a page term record or the record checksum fails.
-// This is a non-method function to make it clear it does not mutate the reader.
-func (r *LiveReader) readRecord() ([]byte, int, error) {
-	// Special case: for recPageTerm, check that are all zeros to end of page,
-	// consume them but don't return them.
-	if r.buf[r.readIndex] == byte(recPageTerm) {
-		// End of page won't necessarily be end of buffer, as we may have
-		// got misaligned by records spanning page boundaries.
-		// r.total % pageSize is the offset into the current page
-		// that r.readIndex points to in buf.  Therefore
-		// pageSize - (r.total % pageSize) is the amount left to read of
-		// the current page.
-		remaining := int(pageSize - (r.total % pageSize))
-		if r.readIndex+remaining > r.writeIndex {
-			return nil, 0, io.EOF
-		}
-
-		for i := r.readIndex; i < r.readIndex+remaining; i++ {
-			if r.buf[i] != 0 {
-				return nil, 0, errors.New("unexpected non-zero byte in page term bytes")
-			}
-		}
-
-		return nil, remaining, nil
-	}
-
-	// Not a recPageTerm; read the record and check the checksum.
-	if r.writeIndex-r.readIndex < recordHeaderSize {
-		return nil, 0, io.EOF
-	}
-
-	copy(r.hdr[:], r.buf[r.readIndex:r.readIndex+recordHeaderSize])
-	length := int(binary.BigEndian.Uint16(r.hdr[1:]))
-	crc := binary.BigEndian.Uint32(r.hdr[3:])
-	if r.readIndex+recordHeaderSize+length > pageSize {
-		if !r.permissive {
-			return nil, 0, fmt.Errorf("record would overflow current page: %d > %d", r.readIndex+recordHeaderSize+length, pageSize)
-		}
-		r.metrics.readerCorruptionErrors.WithLabelValues("record_span_page").Inc()
-		level.Warn(r.logger).Log("msg", "record spans page boundaries", "start", r.readIndex, "end", recordHeaderSize+length, "pageSize", pageSize)
-	}
-	if recordHeaderSize+length > pageSize {
-		return nil, 0, fmt.Errorf("record length greater than a single page: %d > %d", recordHeaderSize+length, pageSize)
-	}
-	if r.readIndex+recordHeaderSize+length > r.writeIndex {
-		return nil, 0, io.EOF
-	}
-
-	rec := r.buf[r.readIndex+recordHeaderSize : r.readIndex+recordHeaderSize+length]
-	if c := crc32.Checksum(rec, castagnoliTable); c != crc {
-		return nil, 0, errors.Errorf("unexpected checksum %x, expected %x", c, crc)
-	}
-
-	return rec, length + recordHeaderSize, nil
-}
-
-func min(i, j int) int {
-	if i < j {
-		return i
-	}
-	return j
-}
diff --git a/vendor/github.com/prometheus/tsdb/wal/reader.go b/vendor/github.com/prometheus/tsdb/wal/reader.go
deleted file mode 100644
index 7612f8775f..0000000000
--- a/vendor/github.com/prometheus/tsdb/wal/reader.go
+++ /dev/null
@@ -1,200 +0,0 @@
-// Copyright 2019 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.
-
-package wal
-
-import (
-	"encoding/binary"
-	"hash/crc32"
-	"io"
-
-	"github.com/golang/snappy"
-	"github.com/pkg/errors"
-)
-
-// Reader reads WAL records from an io.Reader.
-type Reader struct {
-	rdr       io.Reader
-	err       error
-	rec       []byte
-	snappyBuf []byte
-	buf       [pageSize]byte
-	total     int64   // Total bytes processed.
-	curRecTyp recType // Used for checking that the last record is not torn.
-}
-
-// NewReader returns a new reader.
-func NewReader(r io.Reader) *Reader {
-	return &Reader{rdr: r}
-}
-
-// Next advances the reader to the next records and returns true if it exists.
-// It must not be called again after it returned false.
-func (r *Reader) Next() bool {
-	err := r.next()
-	if errors.Cause(err) == io.EOF {
-		// The last WAL segment record shouldn't be torn(should be full or last).
-		// The last record would be torn after a crash just before
-		// the last record part could be persisted to disk.
-		if r.curRecTyp == recFirst || r.curRecTyp == recMiddle {
-			r.err = errors.New("last record is torn")
-		}
-		return false
-	}
-	r.err = err
-	return r.err == nil
-}
-
-func (r *Reader) next() (err error) {
-	// We have to use r.buf since allocating byte arrays here fails escape
-	// analysis and ends up on the heap, even though it seemingly should not.
-	hdr := r.buf[:recordHeaderSize]
-	buf := r.buf[recordHeaderSize:]
-
-	r.rec = r.rec[:0]
-	r.snappyBuf = r.snappyBuf[:0]
-
-	i := 0
-	for {
-		if _, err = io.ReadFull(r.rdr, hdr[:1]); err != nil {
-			return errors.Wrap(err, "read first header byte")
-		}
-		r.total++
-		r.curRecTyp = recTypeFromHeader(hdr[0])
-		compressed := hdr[0]&snappyMask != 0
-
-		// Gobble up zero bytes.
-		if r.curRecTyp == recPageTerm {
-			// recPageTerm is a single byte that indicates the rest of the page is padded.
-			// If it's the first byte in a page, buf is too small and
-			// needs to be resized to fit pageSize-1 bytes.
-			buf = r.buf[1:]
-
-			// We are pedantic and check whether the zeros are actually up
-			// to a page boundary.
-			// It's not strictly necessary but may catch sketchy state early.
-			k := pageSize - (r.total % pageSize)
-			if k == pageSize {
-				continue // Initial 0 byte was last page byte.
-			}
-			n, err := io.ReadFull(r.rdr, buf[:k])
-			if err != nil {
-				return errors.Wrap(err, "read remaining zeros")
-			}
-			r.total += int64(n)
-
-			for _, c := range buf[:k] {
-				if c != 0 {
-					return errors.New("unexpected non-zero byte in padded page")
-				}
-			}
-			continue
-		}
-		n, err := io.ReadFull(r.rdr, hdr[1:])
-		if err != nil {
-			return errors.Wrap(err, "read remaining header")
-		}
-		r.total += int64(n)
-
-		var (
-			length = binary.BigEndian.Uint16(hdr[1:])
-			crc    = binary.BigEndian.Uint32(hdr[3:])
-		)
-
-		if length > pageSize-recordHeaderSize {
-			return errors.Errorf("invalid record size %d", length)
-		}
-		n, err = io.ReadFull(r.rdr, buf[:length])
-		if err != nil {
-			return err
-		}
-		r.total += int64(n)
-
-		if n != int(length) {
-			return errors.Errorf("invalid size: expected %d, got %d", length, n)
-		}
-		if c := crc32.Checksum(buf[:length], castagnoliTable); c != crc {
-			return errors.Errorf("unexpected checksum %x, expected %x", c, crc)
-		}
-
-		if compressed {
-			r.snappyBuf = append(r.snappyBuf, buf[:length]...)
-		} else {
-			r.rec = append(r.rec, buf[:length]...)
-		}
-
-		if err := validateRecord(r.curRecTyp, i); err != nil {
-			return err
-		}
-		if r.curRecTyp == recLast || r.curRecTyp == recFull {
-			if compressed && len(r.snappyBuf) > 0 {
-				// The snappy library uses `len` to calculate if we need a new buffer.
-				// In order to allocate as few buffers as possible make the length
-				// equal to the capacity.
-				r.rec = r.rec[:cap(r.rec)]
-				r.rec, err = snappy.Decode(r.rec, r.snappyBuf)
-				return err
-			}
-			return nil
-		}
-
-		// Only increment i for non-zero records since we use it
-		// to determine valid content record sequences.
-		i++
-	}
-}
-
-// Err returns the last encountered error wrapped in a corruption error.
-// If the reader does not allow to infer a segment index and offset, a total
-// offset in the reader stream will be provided.
-func (r *Reader) Err() error {
-	if r.err == nil {
-		return nil
-	}
-	if b, ok := r.rdr.(*segmentBufReader); ok {
-		return &CorruptionErr{
-			Err:     r.err,
-			Dir:     b.segs[b.cur].Dir(),
-			Segment: b.segs[b.cur].Index(),
-			Offset:  int64(b.off),
-		}
-	}
-	return &CorruptionErr{
-		Err:     r.err,
-		Segment: -1,
-		Offset:  r.total,
-	}
-}
-
-// Record returns the current record. The returned byte slice is only
-// valid until the next call to Next.
-func (r *Reader) Record() []byte {
-	return r.rec
-}
-
-// Segment returns the current segment being read.
-func (r *Reader) Segment() int {
-	if b, ok := r.rdr.(*segmentBufReader); ok {
-		return b.segs[b.cur].Index()
-	}
-	return -1
-}
-
-// Offset returns the current position of the segment being read.
-func (r *Reader) Offset() int64 {
-	if b, ok := r.rdr.(*segmentBufReader); ok {
-		return int64(b.off)
-	}
-	return r.total
-}
diff --git a/vendor/github.com/prometheus/tsdb/wal/wal.go b/vendor/github.com/prometheus/tsdb/wal/wal.go
deleted file mode 100644
index 878aae6ba1..0000000000
--- a/vendor/github.com/prometheus/tsdb/wal/wal.go
+++ /dev/null
@@ -1,852 +0,0 @@
-// Copyright 2017 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.
-
-package wal
-
-import (
-	"bufio"
-	"encoding/binary"
-	"fmt"
-	"hash/crc32"
-	"io"
-	"os"
-	"path/filepath"
-	"sort"
-	"strconv"
-	"sync"
-	"time"
-
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
-	"github.com/golang/snappy"
-	"github.com/pkg/errors"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/tsdb/fileutil"
-)
-
-const (
-	DefaultSegmentSize = 128 * 1024 * 1024 // 128 MB
-	pageSize           = 32 * 1024         // 32KB
-	recordHeaderSize   = 7
-)
-
-// The table gets initialized with sync.Once but may still cause a race
-// with any other use of the crc32 package anywhere. Thus we initialize it
-// before.
-var castagnoliTable = crc32.MakeTable(crc32.Castagnoli)
-
-// page is an in memory buffer used to batch disk writes.
-// Records bigger than the page size are split and flushed separately.
-// A flush is triggered when a single records doesn't fit the page size or
-// when the next record can't fit in the remaining free page space.
-type page struct {
-	alloc   int
-	flushed int
-	buf     [pageSize]byte
-}
-
-func (p *page) remaining() int {
-	return pageSize - p.alloc
-}
-
-func (p *page) full() bool {
-	return pageSize-p.alloc < recordHeaderSize
-}
-
-// Segment represents a segment file.
-type Segment struct {
-	*os.File
-	dir string
-	i   int
-}
-
-// Index returns the index of the segment.
-func (s *Segment) Index() int {
-	return s.i
-}
-
-// Dir returns the directory of the segment.
-func (s *Segment) Dir() string {
-	return s.dir
-}
-
-// CorruptionErr is an error that's returned when corruption is encountered.
-type CorruptionErr struct {
-	Dir     string
-	Segment int
-	Offset  int64
-	Err     error
-}
-
-func (e *CorruptionErr) Error() string {
-	if e.Segment < 0 {
-		return fmt.Sprintf("corruption after %d bytes: %s", e.Offset, e.Err)
-	}
-	return fmt.Sprintf("corruption in segment %s at %d: %s", SegmentName(e.Dir, e.Segment), e.Offset, e.Err)
-}
-
-// OpenWriteSegment opens segment k in dir. The returned segment is ready for new appends.
-func OpenWriteSegment(logger log.Logger, dir string, k int) (*Segment, error) {
-	segName := SegmentName(dir, k)
-	f, err := os.OpenFile(segName, os.O_WRONLY|os.O_APPEND, 0666)
-	if err != nil {
-		return nil, err
-	}
-	stat, err := f.Stat()
-	if err != nil {
-		f.Close()
-		return nil, err
-	}
-	// If the last page is torn, fill it with zeros.
-	// In case it was torn after all records were written successfully, this
-	// will just pad the page and everything will be fine.
-	// If it was torn mid-record, a full read (which the caller should do anyway
-	// to ensure integrity) will detect it as a corruption by the end.
-	if d := stat.Size() % pageSize; d != 0 {
-		level.Warn(logger).Log("msg", "last page of the wal is torn, filling it with zeros", "segment", segName)
-		if _, err := f.Write(make([]byte, pageSize-d)); err != nil {
-			f.Close()
-			return nil, errors.Wrap(err, "zero-pad torn page")
-		}
-	}
-	return &Segment{File: f, i: k, dir: dir}, nil
-}
-
-// CreateSegment creates a new segment k in dir.
-func CreateSegment(dir string, k int) (*Segment, error) {
-	f, err := os.OpenFile(SegmentName(dir, k), os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
-	if err != nil {
-		return nil, err
-	}
-	return &Segment{File: f, i: k, dir: dir}, nil
-}
-
-// OpenReadSegment opens the segment with the given filename.
-func OpenReadSegment(fn string) (*Segment, error) {
-	k, err := strconv.Atoi(filepath.Base(fn))
-	if err != nil {
-		return nil, errors.New("not a valid filename")
-	}
-	f, err := os.Open(fn)
-	if err != nil {
-		return nil, err
-	}
-	return &Segment{File: f, i: k, dir: filepath.Dir(fn)}, nil
-}
-
-// WAL is a write ahead log that stores records in segment files.
-// It must be read from start to end once before logging new data.
-// If an error occurs during read, the repair procedure must be called
-// before it's safe to do further writes.
-//
-// Segments are written to in pages of 32KB, with records possibly split
-// across page boundaries.
-// Records are never split across segments to allow full segments to be
-// safely truncated. It also ensures that torn writes never corrupt records
-// beyond the most recent segment.
-type WAL struct {
-	dir         string
-	logger      log.Logger
-	segmentSize int
-	mtx         sync.RWMutex
-	segment     *Segment // Active segment.
-	donePages   int      // Pages written to the segment.
-	page        *page    // Active page.
-	stopc       chan chan struct{}
-	actorc      chan func()
-	closed      bool // To allow calling Close() more than once without blocking.
-	compress    bool
-	snappyBuf   []byte
-
-	fsyncDuration   prometheus.Summary
-	pageFlushes     prometheus.Counter
-	pageCompletions prometheus.Counter
-	truncateFail    prometheus.Counter
-	truncateTotal   prometheus.Counter
-	currentSegment  prometheus.Gauge
-}
-
-// New returns a new WAL over the given directory.
-func New(logger log.Logger, reg prometheus.Registerer, dir string, compress bool) (*WAL, error) {
-	return NewSize(logger, reg, dir, DefaultSegmentSize, compress)
-}
-
-// NewSize returns a new WAL over the given directory.
-// New segments are created with the specified size.
-func NewSize(logger log.Logger, reg prometheus.Registerer, dir string, segmentSize int, compress bool) (*WAL, error) {
-	if segmentSize%pageSize != 0 {
-		return nil, errors.New("invalid segment size")
-	}
-	if err := os.MkdirAll(dir, 0777); err != nil {
-		return nil, errors.Wrap(err, "create dir")
-	}
-	if logger == nil {
-		logger = log.NewNopLogger()
-	}
-	w := &WAL{
-		dir:         dir,
-		logger:      logger,
-		segmentSize: segmentSize,
-		page:        &page{},
-		actorc:      make(chan func(), 100),
-		stopc:       make(chan chan struct{}),
-		compress:    compress,
-	}
-	registerMetrics(reg, w)
-
-	_, j, err := w.Segments()
-	// Index of the Segment we want to open and write to.
-	writeSegmentIndex := 0
-	if err != nil {
-		return nil, errors.Wrap(err, "get segment range")
-	}
-	// If some segments already exist create one with a higher index than the last segment.
-	if j != -1 {
-		writeSegmentIndex = j + 1
-	}
-
-	segment, err := CreateSegment(w.dir, writeSegmentIndex)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := w.setSegment(segment); err != nil {
-		return nil, err
-	}
-
-	go w.run()
-
-	return w, nil
-}
-
-// Open an existing WAL.
-func Open(logger log.Logger, reg prometheus.Registerer, dir string) (*WAL, error) {
-	if logger == nil {
-		logger = log.NewNopLogger()
-	}
-	w := &WAL{
-		dir:    dir,
-		logger: logger,
-	}
-
-	registerMetrics(reg, w)
-	return w, nil
-}
-
-func registerMetrics(reg prometheus.Registerer, w *WAL) {
-	w.fsyncDuration = prometheus.NewSummary(prometheus.SummaryOpts{
-		Name:       "prometheus_tsdb_wal_fsync_duration_seconds",
-		Help:       "Duration of WAL fsync.",
-		Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
-	})
-	w.pageFlushes = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_wal_page_flushes_total",
-		Help: "Total number of page flushes.",
-	})
-	w.pageCompletions = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_wal_completed_pages_total",
-		Help: "Total number of completed pages.",
-	})
-	w.truncateFail = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_wal_truncations_failed_total",
-		Help: "Total number of WAL truncations that failed.",
-	})
-	w.truncateTotal = prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "prometheus_tsdb_wal_truncations_total",
-		Help: "Total number of WAL truncations attempted.",
-	})
-	w.currentSegment = prometheus.NewGauge(prometheus.GaugeOpts{
-		Name: "prometheus_tsdb_wal_segment_current",
-		Help: "WAL segment index that TSDB is currently writing to.",
-	})
-	if reg != nil {
-		reg.MustRegister(w.fsyncDuration, w.pageFlushes, w.pageCompletions, w.truncateFail, w.truncateTotal, w.currentSegment)
-	}
-}
-
-// CompressionEnabled returns if compression is enabled on this WAL.
-func (w *WAL) CompressionEnabled() bool {
-	return w.compress
-}
-
-// Dir returns the directory of the WAL.
-func (w *WAL) Dir() string {
-	return w.dir
-}
-
-func (w *WAL) run() {
-Loop:
-	for {
-		select {
-		case f := <-w.actorc:
-			f()
-		case donec := <-w.stopc:
-			close(w.actorc)
-			defer close(donec)
-			break Loop
-		}
-	}
-	// Drain and process any remaining functions.
-	for f := range w.actorc {
-		f()
-	}
-}
-
-// Repair attempts to repair the WAL based on the error.
-// It discards all data after the corruption.
-func (w *WAL) Repair(origErr error) error {
-	// We could probably have a mode that only discards torn records right around
-	// the corruption to preserve as data much as possible.
-	// But that's not generally applicable if the records have any kind of causality.
-	// Maybe as an extra mode in the future if mid-WAL corruptions become
-	// a frequent concern.
-	err := errors.Cause(origErr) // So that we can pick up errors even if wrapped.
-
-	cerr, ok := err.(*CorruptionErr)
-	if !ok {
-		return errors.Wrap(origErr, "cannot handle error")
-	}
-	if cerr.Segment < 0 {
-		return errors.New("corruption error does not specify position")
-	}
-	level.Warn(w.logger).Log("msg", "starting corruption repair",
-		"segment", cerr.Segment, "offset", cerr.Offset)
-
-	// All segments behind the corruption can no longer be used.
-	segs, err := listSegments(w.dir)
-	if err != nil {
-		return errors.Wrap(err, "list segments")
-	}
-	level.Warn(w.logger).Log("msg", "deleting all segments newer than corrupted segment", "segment", cerr.Segment)
-
-	for _, s := range segs {
-		if w.segment.i == s.index {
-			// The active segment needs to be removed,
-			// close it first (Windows!). Can be closed safely
-			// as we set the current segment to repaired file
-			// below.
-			if err := w.segment.Close(); err != nil {
-				return errors.Wrap(err, "close active segment")
-			}
-		}
-		if s.index <= cerr.Segment {
-			continue
-		}
-		if err := os.Remove(filepath.Join(w.dir, s.name)); err != nil {
-			return errors.Wrapf(err, "delete segment:%v", s.index)
-		}
-	}
-	// Regardless of the corruption offset, no record reaches into the previous segment.
-	// So we can safely repair the WAL by removing the segment and re-inserting all
-	// its records up to the corruption.
-	level.Warn(w.logger).Log("msg", "rewrite corrupted segment", "segment", cerr.Segment)
-
-	fn := SegmentName(w.dir, cerr.Segment)
-	tmpfn := fn + ".repair"
-
-	if err := fileutil.Rename(fn, tmpfn); err != nil {
-		return err
-	}
-	// Create a clean segment and make it the active one.
-	s, err := CreateSegment(w.dir, cerr.Segment)
-	if err != nil {
-		return err
-	}
-	if err := w.setSegment(s); err != nil {
-		return err
-	}
-
-	f, err := os.Open(tmpfn)
-	if err != nil {
-		return errors.Wrap(err, "open segment")
-	}
-	defer f.Close()
-
-	r := NewReader(bufio.NewReader(f))
-
-	for r.Next() {
-		// Add records only up to the where the error was.
-		if r.Offset() >= cerr.Offset {
-			break
-		}
-		if err := w.Log(r.Record()); err != nil {
-			return errors.Wrap(err, "insert record")
-		}
-	}
-	// We expect an error here from r.Err(), so nothing to handle.
-
-	// We need to pad to the end of the last page in the repaired segment
-	w.flushPage(true)
-
-	// We explicitly close even when there is a defer for Windows to be
-	// able to delete it. The defer is in place to close it in-case there
-	// are errors above.
-	if err := f.Close(); err != nil {
-		return errors.Wrap(err, "close corrupted file")
-	}
-	if err := os.Remove(tmpfn); err != nil {
-		return errors.Wrap(err, "delete corrupted segment")
-	}
-
-	// Explicitly close the the segment we just repaired to avoid issues with Windows.
-	s.Close()
-
-	// We always want to start writing to a new Segment rather than an existing
-	// Segment, which is handled by NewSize, but earlier in Repair we're deleting
-	// all segments that come after the corrupted Segment. Recreate a new Segment here.
-	s, err = CreateSegment(w.dir, cerr.Segment+1)
-	if err != nil {
-		return err
-	}
-	if err := w.setSegment(s); err != nil {
-		return err
-	}
-	return nil
-}
-
-// SegmentName builds a segment name for the directory.
-func SegmentName(dir string, i int) string {
-	return filepath.Join(dir, fmt.Sprintf("%08d", i))
-}
-
-// NextSegment creates the next segment and closes the previous one.
-func (w *WAL) NextSegment() error {
-	w.mtx.Lock()
-	defer w.mtx.Unlock()
-	return w.nextSegment()
-}
-
-// nextSegment creates the next segment and closes the previous one.
-func (w *WAL) nextSegment() error {
-	// Only flush the current page if it actually holds data.
-	if w.page.alloc > 0 {
-		if err := w.flushPage(true); err != nil {
-			return err
-		}
-	}
-	next, err := CreateSegment(w.dir, w.segment.Index()+1)
-	if err != nil {
-		return errors.Wrap(err, "create new segment file")
-	}
-	prev := w.segment
-	if err := w.setSegment(next); err != nil {
-		return err
-	}
-
-	// Don't block further writes by fsyncing the last segment.
-	w.actorc <- func() {
-		if err := w.fsync(prev); err != nil {
-			level.Error(w.logger).Log("msg", "sync previous segment", "err", err)
-		}
-		if err := prev.Close(); err != nil {
-			level.Error(w.logger).Log("msg", "close previous segment", "err", err)
-		}
-	}
-	return nil
-}
-
-func (w *WAL) setSegment(segment *Segment) error {
-	w.segment = segment
-
-	// Correctly initialize donePages.
-	stat, err := segment.Stat()
-	if err != nil {
-		return err
-	}
-	w.donePages = int(stat.Size() / pageSize)
-	w.currentSegment.Set(float64(segment.Index()))
-	return nil
-}
-
-// flushPage writes the new contents of the page to disk. If no more records will fit into
-// the page, the remaining bytes will be set to zero and a new page will be started.
-// If clear is true, this is enforced regardless of how many bytes are left in the page.
-func (w *WAL) flushPage(clear bool) error {
-	w.pageFlushes.Inc()
-
-	p := w.page
-	clear = clear || p.full()
-
-	// No more data will fit into the page or an implicit clear.
-	// Enqueue and clear it.
-	if clear {
-		p.alloc = pageSize // Write till end of page.
-	}
-	n, err := w.segment.Write(p.buf[p.flushed:p.alloc])
-	if err != nil {
-		return err
-	}
-	p.flushed += n
-
-	// We flushed an entire page, prepare a new one.
-	if clear {
-		for i := range p.buf {
-			p.buf[i] = 0
-		}
-		p.alloc = 0
-		p.flushed = 0
-		w.donePages++
-		w.pageCompletions.Inc()
-	}
-	return nil
-}
-
-// First Byte of header format:
-// [ 4 bits unallocated] [1 bit snappy compression flag] [ 3 bit record type ]
-const (
-	snappyMask  = 1 << 3
-	recTypeMask = snappyMask - 1
-)
-
-type recType uint8
-
-const (
-	recPageTerm recType = 0 // Rest of page is empty.
-	recFull     recType = 1 // Full record.
-	recFirst    recType = 2 // First fragment of a record.
-	recMiddle   recType = 3 // Middle fragments of a record.
-	recLast     recType = 4 // Final fragment of a record.
-)
-
-func recTypeFromHeader(header byte) recType {
-	return recType(header & recTypeMask)
-}
-
-func (t recType) String() string {
-	switch t {
-	case recPageTerm:
-		return "zero"
-	case recFull:
-		return "full"
-	case recFirst:
-		return "first"
-	case recMiddle:
-		return "middle"
-	case recLast:
-		return "last"
-	default:
-		return "<invalid>"
-	}
-}
-
-func (w *WAL) pagesPerSegment() int {
-	return w.segmentSize / pageSize
-}
-
-// Log writes the records into the log.
-// Multiple records can be passed at once to reduce writes and increase throughput.
-func (w *WAL) Log(recs ...[]byte) error {
-	w.mtx.Lock()
-	defer w.mtx.Unlock()
-	// Callers could just implement their own list record format but adding
-	// a bit of extra logic here frees them from that overhead.
-	for i, r := range recs {
-		if err := w.log(r, i == len(recs)-1); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// log writes rec to the log and forces a flush of the current page if:
-// - the final record of a batch
-// - the record is bigger than the page size
-// - the current page is full.
-func (w *WAL) log(rec []byte, final bool) error {
-	// When the last page flush failed the page will remain full.
-	// When the page is full, need to flush it before trying to add more records to it.
-	if w.page.full() {
-		if err := w.flushPage(true); err != nil {
-			return err
-		}
-	}
-	// If the record is too big to fit within the active page in the current
-	// segment, terminate the active segment and advance to the next one.
-	// This ensures that records do not cross segment boundaries.
-	left := w.page.remaining() - recordHeaderSize                                   // Free space in the active page.
-	left += (pageSize - recordHeaderSize) * (w.pagesPerSegment() - w.donePages - 1) // Free pages in the active segment.
-
-	if len(rec) > left {
-		if err := w.nextSegment(); err != nil {
-			return err
-		}
-	}
-
-	compressed := false
-	if w.compress && len(rec) > 0 {
-		// The snappy library uses `len` to calculate if we need a new buffer.
-		// In order to allocate as few buffers as possible make the length
-		// equal to the capacity.
-		w.snappyBuf = w.snappyBuf[:cap(w.snappyBuf)]
-		w.snappyBuf = snappy.Encode(w.snappyBuf, rec)
-		if len(w.snappyBuf) < len(rec) {
-			rec = w.snappyBuf
-			compressed = true
-		}
-	}
-
-	// Populate as many pages as necessary to fit the record.
-	// Be careful to always do one pass to ensure we write zero-length records.
-	for i := 0; i == 0 || len(rec) > 0; i++ {
-		p := w.page
-
-		// Find how much of the record we can fit into the page.
-		var (
-			l    = min(len(rec), (pageSize-p.alloc)-recordHeaderSize)
-			part = rec[:l]
-			buf  = p.buf[p.alloc:]
-			typ  recType
-		)
-
-		switch {
-		case i == 0 && len(part) == len(rec):
-			typ = recFull
-		case len(part) == len(rec):
-			typ = recLast
-		case i == 0:
-			typ = recFirst
-		default:
-			typ = recMiddle
-		}
-		if compressed {
-			typ |= snappyMask
-		}
-
-		buf[0] = byte(typ)
-		crc := crc32.Checksum(part, castagnoliTable)
-		binary.BigEndian.PutUint16(buf[1:], uint16(len(part)))
-		binary.BigEndian.PutUint32(buf[3:], crc)
-
-		copy(buf[recordHeaderSize:], part)
-		p.alloc += len(part) + recordHeaderSize
-
-		// By definition when a record is split it means its size is bigger than
-		// the page boundary so the current page would be full and needs to be flushed.
-		// On contrary if we wrote a full record, we can fit more records of the batch
-		// into the page before flushing it.
-		if final || typ != recFull || w.page.full() {
-			if err := w.flushPage(false); err != nil {
-				return err
-			}
-		}
-		rec = rec[l:]
-	}
-	return nil
-}
-
-// Segments returns the range [first, n] of currently existing segments.
-// If no segments are found, first and n are -1.
-func (w *WAL) Segments() (first, last int, err error) {
-	refs, err := listSegments(w.dir)
-	if err != nil {
-		return 0, 0, err
-	}
-	if len(refs) == 0 {
-		return -1, -1, nil
-	}
-	return refs[0].index, refs[len(refs)-1].index, nil
-}
-
-// Truncate drops all segments before i.
-func (w *WAL) Truncate(i int) (err error) {
-	w.truncateTotal.Inc()
-	defer func() {
-		if err != nil {
-			w.truncateFail.Inc()
-		}
-	}()
-	refs, err := listSegments(w.dir)
-	if err != nil {
-		return err
-	}
-	for _, r := range refs {
-		if r.index >= i {
-			break
-		}
-		if err = os.Remove(filepath.Join(w.dir, r.name)); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (w *WAL) fsync(f *Segment) error {
-	start := time.Now()
-	err := f.File.Sync()
-	w.fsyncDuration.Observe(time.Since(start).Seconds())
-	return err
-}
-
-// Close flushes all writes and closes active segment.
-func (w *WAL) Close() (err error) {
-	w.mtx.Lock()
-	defer w.mtx.Unlock()
-
-	if w.closed {
-		return errors.New("wal already closed")
-	}
-
-	// Flush the last page and zero out all its remaining size.
-	// We must not flush an empty page as it would falsely signal
-	// the segment is done if we start writing to it again after opening.
-	if w.page.alloc > 0 {
-		if err := w.flushPage(true); err != nil {
-			return err
-		}
-	}
-
-	donec := make(chan struct{})
-	w.stopc <- donec
-	<-donec
-
-	if err = w.fsync(w.segment); err != nil {
-		level.Error(w.logger).Log("msg", "sync previous segment", "err", err)
-	}
-	if err := w.segment.Close(); err != nil {
-		level.Error(w.logger).Log("msg", "close previous segment", "err", err)
-	}
-	w.closed = true
-	return nil
-}
-
-type segmentRef struct {
-	name  string
-	index int
-}
-
-func listSegments(dir string) (refs []segmentRef, err error) {
-	files, err := fileutil.ReadDir(dir)
-	if err != nil {
-		return nil, err
-	}
-	var last int
-	for _, fn := range files {
-		k, err := strconv.Atoi(fn)
-		if err != nil {
-			continue
-		}
-		if len(refs) > 0 && k > last+1 {
-			return nil, errors.New("segments are not sequential")
-		}
-		refs = append(refs, segmentRef{name: fn, index: k})
-		last = k
-	}
-	sort.Slice(refs, func(i, j int) bool {
-		return refs[i].index < refs[j].index
-	})
-	return refs, nil
-}
-
-// SegmentRange groups segments by the directory and the first and last index it includes.
-type SegmentRange struct {
-	Dir         string
-	First, Last int
-}
-
-// NewSegmentsReader returns a new reader over all segments in the directory.
-func NewSegmentsReader(dir string) (io.ReadCloser, error) {
-	return NewSegmentsRangeReader(SegmentRange{dir, -1, -1})
-}
-
-// NewSegmentsRangeReader returns a new reader over the given WAL segment ranges.
-// If first or last are -1, the range is open on the respective end.
-func NewSegmentsRangeReader(sr ...SegmentRange) (io.ReadCloser, error) {
-	var segs []*Segment
-
-	for _, sgmRange := range sr {
-		refs, err := listSegments(sgmRange.Dir)
-		if err != nil {
-			return nil, errors.Wrapf(err, "list segment in dir:%v", sgmRange.Dir)
-		}
-
-		for _, r := range refs {
-			if sgmRange.First >= 0 && r.index < sgmRange.First {
-				continue
-			}
-			if sgmRange.Last >= 0 && r.index > sgmRange.Last {
-				break
-			}
-			s, err := OpenReadSegment(filepath.Join(sgmRange.Dir, r.name))
-			if err != nil {
-				return nil, errors.Wrapf(err, "open segment:%v in dir:%v", r.name, sgmRange.Dir)
-			}
-			segs = append(segs, s)
-		}
-	}
-	return NewSegmentBufReader(segs...), nil
-}
-
-// segmentBufReader is a buffered reader that reads in multiples of pages.
-// The main purpose is that we are able to track segment and offset for
-// corruption reporting.  We have to be careful not to increment curr too
-// early, as it is used by Reader.Err() to tell Repair which segment is corrupt.
-// As such we pad the end of non-page align segments with zeros.
-type segmentBufReader struct {
-	buf  *bufio.Reader
-	segs []*Segment
-	cur  int // Index into segs.
-	off  int // Offset of read data into current segment.
-}
-
-func NewSegmentBufReader(segs ...*Segment) *segmentBufReader {
-	return &segmentBufReader{
-		buf:  bufio.NewReaderSize(segs[0], 16*pageSize),
-		segs: segs,
-	}
-}
-
-func (r *segmentBufReader) Close() (err error) {
-	for _, s := range r.segs {
-		if e := s.Close(); e != nil {
-			err = e
-		}
-	}
-	return err
-}
-
-// Read implements io.Reader.
-func (r *segmentBufReader) Read(b []byte) (n int, err error) {
-	n, err = r.buf.Read(b)
-	r.off += n
-
-	// If we succeeded, or hit a non-EOF, we can stop.
-	if err == nil || err != io.EOF {
-		return n, err
-	}
-
-	// We hit EOF; fake out zero padding at the end of short segments, so we
-	// don't increment curr too early and report the wrong segment as corrupt.
-	if r.off%pageSize != 0 {
-		i := 0
-		for ; n+i < len(b) && (r.off+i)%pageSize != 0; i++ {
-			b[n+i] = 0
-		}
-
-		// Return early, even if we didn't fill b.
-		r.off += i
-		return n + i, nil
-	}
-
-	// There is no more deta left in the curr segment and there are no more
-	// segments left.  Return EOF.
-	if r.cur+1 >= len(r.segs) {
-		return n, io.EOF
-	}
-
-	// Move to next segment.
-	r.cur++
-	r.off = 0
-	r.buf.Reset(r.segs[r.cur])
-	return n, nil
-}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 8c72f37329..3e1a9be45d 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -73,6 +73,8 @@ github.com/cespare/xxhash
 github.com/davecgh/go-spew/spew
 # github.com/dgrijalva/jwt-go v3.2.0+incompatible
 github.com/dgrijalva/jwt-go
+# github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954
+github.com/dgryski/go-sip13
 # github.com/edsrzf/mmap-go v1.0.0
 github.com/edsrzf/mmap-go
 # github.com/evanphx/json-patch v4.1.0+incompatible
@@ -277,17 +279,6 @@ github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg
 # github.com/prometheus/procfs v0.0.2
 github.com/prometheus/procfs
 github.com/prometheus/procfs/internal/fs
-# github.com/prometheus/tsdb v0.10.0
-github.com/prometheus/tsdb
-github.com/prometheus/tsdb/fileutil
-github.com/prometheus/tsdb/labels
-github.com/prometheus/tsdb/wal
-github.com/prometheus/tsdb/chunkenc
-github.com/prometheus/tsdb/chunks
-github.com/prometheus/tsdb/encoding
-github.com/prometheus/tsdb/errors
-github.com/prometheus/tsdb/goversion
-github.com/prometheus/tsdb/index
 # github.com/samuel/go-zookeeper v0.0.0-20161028232340-1d7be4effb13
 github.com/samuel/go-zookeeper/zk
 # github.com/shurcooL/httpfs v0.0.0-20171119174359-809beceb2371
@@ -346,8 +337,8 @@ golang.org/x/oauth2/jwt
 golang.org/x/sync/errgroup
 golang.org/x/sync/semaphore
 # golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e
-golang.org/x/sys/windows
 golang.org/x/sys/unix
+golang.org/x/sys/windows
 # golang.org/x/text v0.3.1-0.20181227161524-e6919f6577db
 golang.org/x/text/secure/bidirule
 golang.org/x/text/unicode/bidi
diff --git a/web/api/v1/api.go b/web/api/v1/api.go
index 8b21c313a4..d3aaaa98bf 100644
--- a/web/api/v1/api.go
+++ b/web/api/v1/api.go
@@ -35,7 +35,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/common/route"
-	tsdbLabels "github.com/prometheus/tsdb/labels"
+	tsdbLabels "github.com/prometheus/prometheus/tsdb/labels"
 
 	"github.com/prometheus/prometheus/config"
 	"github.com/prometheus/prometheus/pkg/gate"
diff --git a/web/api/v1/api_test.go b/web/api/v1/api_test.go
index 05defe96f8..fe9f8cf318 100644
--- a/web/api/v1/api_test.go
+++ b/web/api/v1/api_test.go
@@ -38,7 +38,7 @@ import (
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/common/promlog"
 	"github.com/prometheus/common/route"
-	tsdbLabels "github.com/prometheus/tsdb/labels"
+	tsdbLabels "github.com/prometheus/prometheus/tsdb/labels"
 
 	"github.com/prometheus/prometheus/config"
 	"github.com/prometheus/prometheus/pkg/gate"
diff --git a/web/api/v2/api.go b/web/api/v2/api.go
index 36f1450c8a..83e6b33ef4 100644
--- a/web/api/v2/api.go
+++ b/web/api/v2/api.go
@@ -26,8 +26,8 @@ import (
 
 	"github.com/grpc-ecosystem/grpc-gateway/runtime"
 	"github.com/pkg/errors"
-	"github.com/prometheus/tsdb"
-	tsdbLabels "github.com/prometheus/tsdb/labels"
+	"github.com/prometheus/prometheus/tsdb"
+	tsdbLabels "github.com/prometheus/prometheus/tsdb/labels"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
diff --git a/web/web.go b/web/web.go
index a7ee559f01..1cc4736fd2 100644
--- a/web/web.go
+++ b/web/web.go
@@ -49,7 +49,7 @@ import (
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/common/route"
 	"github.com/prometheus/common/server"
-	"github.com/prometheus/tsdb"
+	"github.com/prometheus/prometheus/tsdb"
 	"github.com/soheilhy/cmux"
 	"golang.org/x/net/netutil"
 	"google.golang.org/grpc"
diff --git a/web/web_test.go b/web/web_test.go
index d93ec058d3..8a1f70bdd0 100644
--- a/web/web_test.go
+++ b/web/web_test.go
@@ -34,8 +34,8 @@ import (
 	"github.com/prometheus/prometheus/rules"
 	"github.com/prometheus/prometheus/scrape"
 	"github.com/prometheus/prometheus/storage/tsdb"
+	libtsdb "github.com/prometheus/prometheus/tsdb"
 	"github.com/prometheus/prometheus/util/testutil"
-	libtsdb "github.com/prometheus/tsdb"
 )
 
 func TestMain(m *testing.M) {