Update deps without licenses

The following packes did not have discernible LICENSE files at the hash we have
vendored:
  github.com/beorn7/perks
  github.com/daviddengcn/go-colortext
  github.com/garyburd/redigo
  github.com/prometheus/common
  github.com/shurcooL/sanitized_anchor_name
  github.com/stretchr/objx

This commit updates all of them and updates the central LICENSE file.

vendor/github.com/prometheus/common/expfmt/decode.go

@@ -37,12 +37,13 @@ type DecodeOptions struct {
 }
 
 // ResponseFormat extracts the correct format from a HTTP response header.
-func ResponseFormat(h http.Header) (Format, error) {
+// If no matching format can be found FormatUnknown is returned.
+func ResponseFormat(h http.Header) Format {
 	ct := h.Get(hdrContentType)
 
 	mediatype, params, err := mime.ParseMediaType(ct)
 	if err != nil {
-		return "", fmt.Errorf("invalid Content-Type header %q: %s", ct, err)
+		return FmtUnknown
 	}
 
 	const (
@@ -52,19 +53,19 @@ func ResponseFormat(h http.Header) (Format, error) {
 
 	switch mediatype {
 	case ProtoType:
-		if p := params["proto"]; p != ProtoProtocol {
-			return "", fmt.Errorf("unrecognized protocol message %s", p)
+		if p, ok := params["proto"]; ok && p != ProtoProtocol {
+			return FmtUnknown
 		}
-		if e := params["encoding"]; e != "delimited" {
-			return "", fmt.Errorf("unsupported encoding %s", e)
+		if e, ok := params["encoding"]; ok && e != "delimited" {
+			return FmtUnknown
 		}
-		return FmtProtoDelim, nil
+		return FmtProtoDelim
 
 	case textType:
 		if v, ok := params["version"]; ok && v != TextVersion {
-			return "", fmt.Errorf("unrecognized protocol version %s", v)
+			return FmtUnknown
 		}
-		return FmtText, nil
+		return FmtText
 
 	case jsonType:
 		var prometheusAPIVersion string
@@ -76,27 +77,26 @@ func ResponseFormat(h http.Header) (Format, error) {
 		}
 
 		switch prometheusAPIVersion {
-		case "0.0.2":
-			return FmtJSON2, nil
+		case "0.0.2", "":
+			return fmtJSON2
 		default:
-			return "", fmt.Errorf("unrecognized API version %s", prometheusAPIVersion)
+			return FmtUnknown
 		}
 	}
 
-	return "", fmt.Errorf("unsupported media type %q, expected %q or %q", mediatype, ProtoType, textType)
+	return FmtUnknown
 }
 
-// NewDecoder returns a new decoder based on the HTTP header.
-func NewDecoder(r io.Reader, format Format) (Decoder, error) {
+// NewDecoder returns a new decoder based on the given input format.
+// If the input format does not imply otherwise, a text format decoder is returned.
+func NewDecoder(r io.Reader, format Format) Decoder {
 	switch format {
 	case FmtProtoDelim:
-		return &protoDecoder{r: r}, nil
-	case FmtText:
-		return &textDecoder{r: r}, nil
-	case FmtJSON2:
-		return newJSON2Decoder(r), nil
+		return &protoDecoder{r: r}
+	case fmtJSON2:
+		return newJSON2Decoder(r)
 	}
-	return nil, fmt.Errorf("unsupported decoding format %q", format)
+	return &textDecoder{r: r}
 }
 
 // protoDecoder implements the Decoder interface for protocol buffers.
@@ -107,7 +107,29 @@ type protoDecoder struct {
 // Decode implements the Decoder interface.
 func (d *protoDecoder) Decode(v *dto.MetricFamily) error {
 	_, err := pbutil.ReadDelimited(d.r, v)
-	return err
+	if err != nil {
+		return err
+	}
+	if !model.IsValidMetricName(model.LabelValue(v.GetName())) {
+		return fmt.Errorf("invalid metric name %q", v.GetName())
+	}
+	for _, m := range v.GetMetric() {
+		if m == nil {
+			continue
+		}
+		for _, l := range m.GetLabel() {
+			if l == nil {
+				continue
+			}
+			if !model.LabelValue(l.GetValue()).IsValid() {
+				return fmt.Errorf("invalid label value %q", l.GetValue())
+			}
+			if !model.LabelName(l.GetName()).IsValid() {
+				return fmt.Errorf("invalid label name %q", l.GetName())
+			}
+		}
+	}
+	return nil
 }
 
 // textDecoder implements the Decoder interface for the text protcol.
@@ -129,13 +151,14 @@ func (d *textDecoder) Decode(v *dto.MetricFamily) error {
 		if len(fams) == 0 {
 			return io.EOF
 		}
+		d.fams = make([]*dto.MetricFamily, 0, len(fams))
 		for _, f := range fams {
 			d.fams = append(d.fams, f)
 		}
 	}
 
-	*v = *d.fams[len(d.fams)-1]
-	d.fams = d.fams[:len(d.fams)-1]
+	*v = *d.fams[0]
+	d.fams = d.fams[1:]
 
 	return nil
 }

vendor/github.com/prometheus/common/expfmt/encode.go

@@ -18,9 +18,9 @@ import (
 	"io"
 	"net/http"
 
-	"bitbucket.org/ww/goautoneg"
 	"github.com/golang/protobuf/proto"
 	"github.com/matttproud/golang_protobuf_extensions/pbutil"
+	"github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg"
 
 	dto "github.com/prometheus/client_model/go"
 )

vendor/github.com/prometheus/common/expfmt/expfmt.go

@@ -24,11 +24,14 @@ const (
 	ProtoFmt      = ProtoType + "; proto=" + ProtoProtocol + ";"
 
 	// The Content-Type values for the different wire protocols.
+	FmtUnknown      Format = `<unknown>`
 	FmtText         Format = `text/plain; version=` + TextVersion
 	FmtProtoDelim   Format = ProtoFmt + ` encoding=delimited`
 	FmtProtoText    Format = ProtoFmt + ` encoding=text`
 	FmtProtoCompact Format = ProtoFmt + ` encoding=compact-text`
-	FmtJSON2        Format = `application/json; version=0.0.2`
+
+	// fmtJSON2 is hidden as it is deprecated.
+	fmtJSON2 Format = `application/json; version=0.0.2`
 )
 
 const (

vendor/github.com/prometheus/common/expfmt/fuzz.go

@@ -20,8 +20,8 @@ import "bytes"
 
 // Fuzz text metric parser with with github.com/dvyukov/go-fuzz:
 //
-//     go-fuzz-build github.com/prometheus/client_golang/text
-//     go-fuzz -bin text-fuzz.zip -workdir fuzz
+//     go-fuzz-build github.com/prometheus/common/expfmt
+//     go-fuzz -bin expfmt-fuzz.zip -workdir fuzz
 //
 // Further input samples should go in the folder fuzz/corpus.
 func Fuzz(in []byte) int {

vendor/github.com/prometheus/common/expfmt/json_decode.go

@@ -46,7 +46,7 @@ type counter002 struct {
 	Value  float64        `json:"value"`
 }
 
-func protoLabelSet(base, ext model.LabelSet) []*dto.LabelPair {
+func protoLabelSet(base, ext model.LabelSet) ([]*dto.LabelPair, error) {
 	labels := base.Clone().Merge(ext)
 	delete(labels, model.MetricNameLabel)
 
@@ -59,6 +59,9 @@ func protoLabelSet(base, ext model.LabelSet) []*dto.LabelPair {
 	pairs := make([]*dto.LabelPair, 0, len(labels))
 
 	for _, ln := range names {
+		if !model.LabelNameRE.MatchString(ln) {
+			return nil, fmt.Errorf("invalid label name %q", ln)
+		}
 		lv := labels[model.LabelName(ln)]
 
 		pairs = append(pairs, &dto.LabelPair{
@@ -67,7 +70,7 @@ func protoLabelSet(base, ext model.LabelSet) []*dto.LabelPair {
 		})
 	}
 
-	return pairs
+	return pairs, nil
 }
 
 func (d *json2Decoder) more() error {
@@ -102,8 +105,12 @@ func (d *json2Decoder) more() error {
 			}
 
 			for _, ctr := range values {
+				labels, err := protoLabelSet(e.BaseLabels, ctr.Labels)
+				if err != nil {
+					return err
+				}
 				f.Metric = append(f.Metric, &dto.Metric{
-					Label: protoLabelSet(e.BaseLabels, ctr.Labels),
+					Label: labels,
 					Untyped: &dto.Untyped{
 						Value: proto.Float64(ctr.Value),
 					},
@@ -131,8 +138,13 @@ func (d *json2Decoder) more() error {
 					// this remains "percentile"
 					hist.Labels["percentile"] = model.LabelValue(q)
 
+					labels, err := protoLabelSet(e.BaseLabels, hist.Labels)
+					if err != nil {
+						return err
+					}
+
 					f.Metric = append(f.Metric, &dto.Metric{
-						Label: protoLabelSet(e.BaseLabels, hist.Labels),
+						Label: labels,
 						Untyped: &dto.Untyped{
 							Value: proto.Float64(value),
 						},

vendor/github.com/prometheus/common/expfmt/text_parse.go

@@ -108,6 +108,13 @@ func (p *TextParser) TextToMetricFamilies(in io.Reader) (map[string]*dto.MetricF
 			delete(p.metricFamiliesByName, k)
 		}
 	}
+	// If p.err is io.EOF now, we have run into a premature end of the input
+	// stream. Turn this error into something nicer and more
+	// meaningful. (io.EOF is often used as a signal for the legitimate end
+	// of an input stream.)
+	if p.err == io.EOF {
+		p.parseError("unexpected end of input stream")
+	}
 	return p.metricFamiliesByName, p.err
 }