Merge pull request #18 from raintank/metricpoint-etc

import changes from latest metrictank

Author: Dieterbe

archive.go

@@ -0,0 +1,90 @@
+package schema
+
+import (
+	"errors"
+	"strconv"
+)
+
+//go:generate stringer -type=Method -linecomment
+
+// Archive represents a metric archive
+// the zero value represents a raw metric
+// any non-zero value represents a certain
+// aggregation method (lower 8 bits) and
+// aggregation span (higher 8 bits)
+type Archive uint16
+
+// important: caller must make sure to call IsSpanValid first
+func NewArchive(method Method, span uint32) Archive {
+	code := uint16(spanHumanToCode[span])
+	return Archive(uint16(method) | code<<8)
+}
+
+// String returns the traditional key suffix like sum_600 etc
+// (invalid to call this for raw archives)
+func (a Archive) String() string {
+	return a.Method().String() + "_" + strconv.FormatInt(int64(a.Span()), 10)
+}
+
+func (a Archive) Method() Method {
+	return Method(a & 0x0F)
+}
+
+func (a Archive) Span() uint32 {
+	return spanCodeToHuman[uint8(a>>8)]
+}
+
+func IsSpanValid(span uint32) bool {
+	_, ok := spanHumanToCode[span]
+	return ok
+}
+
+type Method uint8
+
+const (
+	Avg Method = iota + 1 // avg
+	Sum                   // sum
+	Lst                   // lst
+	Max                   // max
+	Min                   // min
+	Cnt                   // cnt
+)
+
+func MethodFromString(input string) (Method, error) {
+	switch input {
+	case "avg":
+		return Avg, nil
+	case "sum":
+		return Sum, nil
+	case "lst":
+		return Lst, nil
+	case "max":
+		return Max, nil
+	case "min":
+		return Min, nil
+	case "cnt":
+		return Cnt, nil
+	}
+	return 0, errors.New("no such method")
+}
+
+// maps human friendly span numbers (in seconds) to optimized code form
+var spanHumanToCode map[uint32]uint8
+
+// maps span codes to human friendly span numbers in seconds
+var spanCodeToHuman map[uint8]uint32
+
+func init() {
+	// all the aggregation spans we support, their index position in this slice is their code
+	spans := []uint32{2, 5, 10, 15, 30, 60, 90, 120, 150, 300, 600, 900, 1200, 1800, 45 * 60, 3600, 3600 + 30*60, 2 * 3600, 3 * 3600, 4 * 3600, 5 * 3600, 6 * 3600, 8 * 3600, 12 * 3600, 24 * 3600}
+
+	spanHumanToCode = make(map[uint32]uint8)
+	spanCodeToHuman = make(map[uint8]uint32)
+
+	for i, human := range spans {
+		code := uint8(i)
+		spanHumanToCode[human] = code
+		spanCodeToHuman[code] = human
+	}
+
+}

archive_test.go

@@ -0,0 +1,40 @@
+package schema
+
+import "testing"
+
+func TestArchive(t *testing.T) {
+	type c struct {
+		method     Method
+		span       uint32
+		expArchive Archive
+		expStr     string
+	}
+	cases := []c{
+		{Avg, 15, 0x301, "avg_15"},
+		{Cnt, 120, 0x706, "cnt_120"},
+		{Cnt, 3600, 0xF06, "cnt_3600"},
+		{Lst, 7200, 0x1103, "lst_7200"},
+		{Min, 6 * 3600, 0x1505, "min_21600"},
+		{Cnt, 2, 0x6, "cnt_2"},
+		{Avg, 5, 0x101, "avg_5"},
+		{Cnt, 3600 + 30*60, 0x1006, "cnt_5400"},
+	}
+	for i, cas := range cases {
+		arch := NewArchive(cas.method, cas.span)
+		if arch != cas.expArchive {
+			t.Fatalf("case %d: expected archive %d, got %d", i, cas.expArchive, arch)
+		}
+		str := arch.String()
+		if str != cas.expStr {
+			t.Fatalf("case %d: expected string %q, got %q", i, cas.expStr, str)
+		}
+		method := arch.Method()
+		if method != cas.method {
+			t.Fatalf("case %d: expected method %v, got %v", i, cas.method, method)
+		}
+		span := arch.Span()
+		if span != cas.span {
+			t.Fatalf("case %d: expected span %v, got %v", i, cas.span, span)
+		}
+	}
+}

key.go

@@ -0,0 +1,115 @@
+package schema
+
+import (
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+//go:generate msgp
+//msgp:ignore AMKey
+// don't ignore Key, MKey because it's used for MetricDefinition
+
+var ErrStringTooShort = errors.New("string to short")
+var ErrInvalidFormat = errors.New("invalid format")
+
+// Key identifies a metric
+type Key [16]byte
+
+// MKey uniquely identifies a metric in a multi-tenant context
+type MKey struct {
+	Key Key
+	Org uint32
+}
+
+// KeyFromString parses a string id to an MKey
+// string id must be of form orgid.<hexadecimal 128bit hash>
+func MKeyFromString(s string) (MKey, error) {
+	l := len(s)
+
+	// shortest an orgid can be is single digit
+	if l < 34 {
+		return MKey{}, ErrStringTooShort
+	}
+
+	hashStr := s[l-32:]
+	orgStr := s[0 : l-33]
+
+	hash, err := hex.DecodeString(hashStr)
+	if err != nil {
+		return MKey{}, err
+	}
+
+	org, err := strconv.ParseUint(orgStr, 10, 32)
+	if err != nil {
+		return MKey{}, err
+	}
+
+	k := MKey{
+		Org: uint32(org),
+	}
+
+	copy(k.Key[:], hash)
+	return k, nil
+}
+
+func (m MKey) String() string {
+	return fmt.Sprintf("%d.%x", m.Org, m.Key)
+
+}
+
+// AMKey is a multi-tenant key with archive extension
+// so you can refer to rollup archives
+type AMKey struct {
+	MKey    MKey
+	Archive Archive
+}
+
+func (a AMKey) String() string {
+	if a.Archive == 0 {
+		return a.MKey.String()
+	}
+	return a.MKey.String() + "_" + a.Archive.String()
+}
+
+// GetAMKey helps to easily get an AMKey from a given MKey
+func GetAMKey(m MKey, method Method, span uint32) AMKey {
+	return AMKey{
+		MKey:    m,
+		Archive: NewArchive(method, span),
+	}
+}
+
+func AMKeyFromString(s string) (AMKey, error) {
+	underscores := strings.Count(s, "_")
+	amk := AMKey{}
+	switch underscores {
+	case 0:
+		mk, err := MKeyFromString(s)
+		amk.MKey = mk
+		return amk, err
+	case 2:
+		splits := strings.Split(s, "_")
+		mk, err := MKeyFromString(splits[0])
+		if err != nil {
+			return amk, err
+		}
+		amk.MKey = mk
+		method, err := MethodFromString(splits[1])
+		if err != nil {
+			return amk, err
+		}
+		span, err := strconv.ParseInt(splits[2], 10, 32)
+		if err == nil {
+			return amk, err
+		}
+		if !IsSpanValid(uint32(span)) {
+			return amk, fmt.Errorf("invalid span %d", span)
+		}
+		amk.Archive = NewArchive(method, uint32(span))
+		return amk, nil
+	}
+	return amk, ErrInvalidFormat
+}