update influxdb to v1.1.1 and change client to v2

vendor/github.com/influxdata/influxdb/models/inline_fnv.go

@@ -0,0 +1,27 @@
+package models
+
+// from stdlib hash/fnv/fnv.go
+const (
+	prime64  = 1099511628211
+	offset64 = 14695981039346656037
+)
+
+// InlineFNV64a is an alloc-free port of the standard library's fnv64a.
+type InlineFNV64a uint64
+
+func NewInlineFNV64a() InlineFNV64a {
+	return offset64
+}
+
+func (s *InlineFNV64a) Write(data []byte) (int, error) {
+	hash := uint64(*s)
+	for _, c := range data {
+		hash ^= uint64(c)
+		hash *= prime64
+	}
+	*s = InlineFNV64a(hash)
+	return len(data), nil
+}
+func (s *InlineFNV64a) Sum64() uint64 {
+	return uint64(*s)
+}

vendor/github.com/influxdata/influxdb/models/inline_strconv_parse.go

@@ -0,0 +1,38 @@
+package models
+
+import (
+	"reflect"
+	"strconv"
+	"unsafe"
+)
+
+// parseIntBytes is a zero-alloc wrapper around strconv.ParseInt.
+func parseIntBytes(b []byte, base int, bitSize int) (i int64, err error) {
+	s := unsafeBytesToString(b)
+	return strconv.ParseInt(s, base, bitSize)
+}
+
+// parseFloatBytes is a zero-alloc wrapper around strconv.ParseFloat.
+func parseFloatBytes(b []byte, bitSize int) (float64, error) {
+	s := unsafeBytesToString(b)
+	return strconv.ParseFloat(s, bitSize)
+}
+
+// parseBoolBytes is a zero-alloc wrapper around strconv.ParseBool.
+func parseBoolBytes(b []byte) (bool, error) {
+	return strconv.ParseBool(unsafeBytesToString(b))
+}
+
+// unsafeBytesToString converts a []byte to a string without a heap allocation.
+//
+// It is unsafe, and is intended to prepare input to short-lived functions
+// that require strings.
+func unsafeBytesToString(in []byte) string {
+	src := *(*reflect.SliceHeader)(unsafe.Pointer(&in))
+	dst := reflect.StringHeader{
+		Data: src.Data,
+		Len:  src.Len,
+	}
+	s := *(*string)(unsafe.Pointer(&dst))
+	return s
+}

vendor/github.com/influxdata/influxdb/models/rows.go

@@ -1,7 +1,6 @@
 package models
 
 import (
-	"hash/fnv"
 	"sort"
 )
 
@@ -11,7 +10,6 @@ type Row struct {
 	Tags    map[string]string `json:"tags,omitempty"`
 	Columns []string          `json:"columns,omitempty"`
 	Values  [][]interface{}   `json:"values,omitempty"`
-	Err     error             `json:"err,omitempty"`
 }
 
 // SameSeries returns true if r contains values for the same series as o.
@@ -21,7 +19,7 @@ func (r *Row) SameSeries(o *Row) bool {
 
 // tagsHash returns a hash of tag key/value pairs.
 func (r *Row) tagsHash() uint64 {
-	h := fnv.New64a()
+	h := NewInlineFNV64a()
 	keys := r.tagsKeys()
 	for _, k := range keys {
 		h.Write([]byte(k))

vendor/github.com/influxdata/influxdb/models/statistic.go

@@ -0,0 +1,40 @@
+package models
+
+type Statistic struct {
+	Name   string                 `json:"name"`
+	Tags   map[string]string      `json:"tags"`
+	Values map[string]interface{} `json:"values"`
+}
+
+func NewStatistic(name string) Statistic {
+	return Statistic{
+		Name:   name,
+		Tags:   make(map[string]string),
+		Values: make(map[string]interface{}),
+	}
+}
+
+// StatisticTags is a map that can be merged with others without causing
+// mutations to either map.
+type StatisticTags map[string]string
+
+// Merge creates a new map containing the merged contents of tags and t.
+// If both tags and the receiver map contain the same key, the value in tags
+// is used in the resulting map.
+//
+// Merge always returns a usable map.
+func (t StatisticTags) Merge(tags map[string]string) map[string]string {
+	// Add everything in tags to the result.
+	out := make(map[string]string, len(tags))
+	for k, v := range tags {
+		out[k] = v
+	}
+
+	// Only add values from t that don't appear in tags.
+	for k, v := range t {
+		if _, ok := tags[k]; !ok {
+			out[k] = v
+		}
+	}
+	return out
+}

vendor/github.com/influxdata/influxdb/models/time.go

@@ -9,14 +9,36 @@ import (
 	"time"
 )
 
+const (
+	// MinNanoTime is the minumum time that can be represented.
+	//
+	// 1677-09-21 00:12:43.145224194 +0000 UTC
+	//
+	// The two lowest minimum integers are used as sentinel values.  The
+	// minimum value needs to be used as a value lower than any other value for
+	// comparisons and another separate value is needed to act as a sentinel
+	// default value that is unusable by the user, but usable internally.
+	// Because these two values need to be used for a special purpose, we do
+	// not allow users to write points at these two times.
+	MinNanoTime = int64(math.MinInt64) + 2
+
+	// MaxNanoTime is the maximum time that can be represented.
+	//
+	// 2262-04-11 23:47:16.854775806 +0000 UTC
+	//
+	// The highest time represented by a nanosecond needs to be used for an
+	// exclusive range in the shard group, so the maximum time needs to be one
+	// less than the possible maximum number of nanoseconds representable by an
+	// int64 so that we don't lose a point at that one time.
+	MaxNanoTime = int64(math.MaxInt64) - 1
+)
+
 var (
-	// MaxNanoTime is the maximum time that can be represented via int64 nanoseconds since the epoch.
-	MaxNanoTime = time.Unix(0, math.MaxInt64).UTC()
-	// MinNanoTime is the minumum time that can be represented via int64 nanoseconds since the epoch.
-	MinNanoTime = time.Unix(0, math.MinInt64).UTC()
+	minNanoTime = time.Unix(0, MinNanoTime).UTC()
+	maxNanoTime = time.Unix(0, MaxNanoTime).UTC()
 
 	// ErrTimeOutOfRange gets returned when time is out of the representable range using int64 nanoseconds since the epoch.
-	ErrTimeOutOfRange = fmt.Errorf("time outside range %s - %s", MinNanoTime, MaxNanoTime)
+	ErrTimeOutOfRange = fmt.Errorf("time outside range %d - %d", MinNanoTime, MaxNanoTime)
 )
 
 // SafeCalcTime safely calculates the time given. Will return error if the time is outside the
@@ -24,7 +46,8 @@ var (
 func SafeCalcTime(timestamp int64, precision string) (time.Time, error) {
 	mult := GetPrecisionMultiplier(precision)
 	if t, ok := safeSignedMult(timestamp, mult); ok {
-		return time.Unix(0, t).UTC(), nil
+		tme := time.Unix(0, t).UTC()
+		return tme, CheckTime(tme)
 	}
 
 	return time.Time{}, ErrTimeOutOfRange
@@ -32,7 +55,7 @@ func SafeCalcTime(timestamp int64, precision string) (time.Time, error) {
 
 // CheckTime checks that a time is within the safe range.
 func CheckTime(t time.Time) error {
-	if t.Before(MinNanoTime) || t.After(MaxNanoTime) {
+	if t.Before(minNanoTime) || t.After(maxNanoTime) {
 		return ErrTimeOutOfRange
 	}
 	return nil
@@ -43,7 +66,7 @@ func safeSignedMult(a, b int64) (int64, bool) {
 	if a == 0 || b == 0 || a == 1 || b == 1 {
 		return a * b, true
 	}
-	if a == math.MinInt64 || b == math.MaxInt64 {
+	if a == MinNanoTime || b == MaxNanoTime {
 		return 0, false
 	}
 	c := a * b