do not try to decode openmetrics, which is not supported

Signed-off-by: Owen Williams <owen.williams@grafana.com>

Author: ywwg

expfmt/decode.go

@@ -15,6 +15,7 @@ package expfmt
 
 import (
 	"bufio"
+	"errors"
 	"fmt"
 	"io"
 	"math"
@@ -73,14 +74,17 @@ func ResponseFormat(h http.Header) Format {
 
 // 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 {
+func NewDecoder(r io.Reader, format Format) (Decoder, error) {
 	switch format.FormatType() {
 	case TypeProtoDelim:
-		return &protoDecoder{r: bufio.NewReader(r)}
+		return &protoDecoder{r: bufio.NewReader(r)}, nil
 	case TypeProtoText, TypeProtoCompact:
-		return &prototextDecoder{r: r}
+		return &prototextDecoder{r: r}, nil
 	}
-	return &textDecoder{r: r}
+	if format.FormatType() == TypeOpenMetrics {
+		return nil, errors.New("cannot decode openmetrics")
+	}
+	return &textDecoder{r: r}, nil
 }
 
 // protoDecoder implements the Decoder interface for protocol buffers.

expfmt/decode_test.go

@@ -408,7 +408,8 @@ func TestProtoMultiMessageDecoder(t *testing.T) {
 	require.NoErrorf(t, err, "Reading file failed: %v", err)
 
 	buf := bytes.NewReader(data)
-	decoder := NewDecoder(buf, FmtProtoDelim)
+	decoder, err := NewDecoder(buf, FmtProtoDelim)
+	require.NoError(t, err)
 	var metrics []*dto.MetricFamily
 	for {
 		var mf dto.MetricFamily
@@ -557,7 +558,8 @@ func TestTextDecoderWithBufioReader(t *testing.T) {
 
 	var decoded bool
 	r := bufio.NewReader(strings.NewReader(example))
-	dec := NewDecoder(r, FmtText)
+	dec, err := NewDecoder(r, FmtText)
+	require.NoError(t, err)
 	for {
 		var mf dto.MetricFamily
 		if err := dec.Decode(&mf); err != nil {

expfmt/encode_test.go

@@ -344,7 +344,10 @@ func TestEscapedEncode(t *testing.T) {
 		t.Errorf("expected the output bytes buffer to be non-empty")
 	}
 
-	dec := NewDecoder(bytes.NewReader(out), FmtProtoDelim)
+	dec, err := NewDecoder(bytes.NewReader(out), FmtProtoDelim)
+	if err != nil {
+		t.Errorf("unexpected error calling NewDecoder: %s", err.Error())
+	}
 	var gotFamily dto.MetricFamily
 	err = dec.Decode(&gotFamily)
 	if err != nil {
@@ -366,7 +369,10 @@ func TestEscapedEncode(t *testing.T) {
 	if len(out) == 0 {
 		t.Errorf("expected the output bytes buffer to be non-empty")
 	}
-	dec = NewDecoder(bytes.NewReader(out), FmtProtoCompact)
+	dec, err = NewDecoder(bytes.NewReader(out), FmtProtoCompact)
+	if err != nil {
+		t.Errorf("unexpected error calling NewDecoder: %s", err.Error())
+	}
 	err = dec.Decode(&gotFamily)
 	if err != nil {
 		t.Errorf("unexpected error during proto decode: %s", err.Error())
@@ -386,7 +392,10 @@ func TestEscapedEncode(t *testing.T) {
 	if len(out) == 0 {
 		t.Errorf("expected the output bytes buffer to be non-empty")
 	}
-	dec = NewDecoder(bytes.NewReader(out), FmtProtoText)
+	dec, err = NewDecoder(bytes.NewReader(out), FmtProtoText)
+	if err != nil {
+		t.Errorf("unexpected error calling NewDecoder: %s", err.Error())
+	}
 	err = dec.Decode(&gotFamily)
 	if err != nil {
 		t.Errorf("unexpected error during proto decode: %s", err.Error())
@@ -496,16 +505,8 @@ func TestDottedEncode(t *testing.T) {
 			expectMetricName: "foo.metric",
 			expectLabelName:  "dotted.label.name",
 		},
-		{
-			format:           FmtOpenMetrics_1_0_0,
-			expectMetricName: "foo_metric",
-			expectLabelName:  "dotted_label_name",
-		},
-		{
-			format:           FmtOpenMetrics_1_0_0.WithEscapingScheme(model.NoEscaping),
-			expectMetricName: "foo.metric",
-			expectLabelName:  "dotted.label.name",
-		},
+		// common library does not support open metrics parsing so we do not test
+		// that here.
 	}
 
 	for i, scenario := range scenarios {
@@ -517,7 +518,10 @@ func TestDottedEncode(t *testing.T) {
 			continue
 		}
 
-		dec := NewDecoder(bytes.NewReader(out.Bytes()), scenario.format)
+		dec, err := NewDecoder(bytes.NewReader(out.Bytes()), scenario.format)
+		if err != nil {
+			t.Errorf("unexpected error calling NewDecoder: %s", err.Error())
+		}
 		var gotFamily dto.MetricFamily
 		err = dec.Decode(&gotFamily)
 		if err != nil {

expfmt/text_parse.go

@@ -574,20 +574,19 @@ func (p *TextParser) readingType() stateFn {
 	if p.readTokenUntilNewline(false); p.err != nil {
 		return nil // Unexpected end of input.
 	}
-	var metricType int32
 	typString := strings.ToUpper(p.currentToken.String())
 	// OpenMetrics uses UNKNOWN for untyped metrics instead of UNTYPED, so we add
 	// a special case for that here.
 	if typString == "UNKNOWN" {
-		metricType = int32(dto.MetricType_UNTYPED)
-	} else {
-		var ok bool
-		metricType, ok = dto.MetricType_value[typString]
-		if !ok {
-			p.parseError(fmt.Sprintf("unknown metric type %q", p.currentToken.String()))
-			return nil
-		}
+		p.parseError("found metric type UNKNOWN, is the input OpenMetrics instead of Prometheus format?")
+		return nil
 	}
+	metricType, ok := dto.MetricType_value[typString]
+	if !ok {
+		p.parseError(fmt.Sprintf("unknown metric type %q", p.currentToken.String()))
+		return nil
+	}
+
 	p.currentMF.Type = dto.MetricType(metricType).Enum()
 	return p.startOfLine
 }

expfmt/text_parse_test.go

@@ -181,7 +181,6 @@ my_summary{n1="val1",quantile="0.9"} 140 1
 my_summary_count{n1="val1"} 42
 # Latest timestamp wins in case of a summary.
 my_summary_sum{n1="val1"} 4711 2
-# TYPE fake_sum unknown
 fake_sum{n1="val1"} 2001
 # TYPE another_summary summary
 another_summary_count{n2="val2",n1="val1"} 20
@@ -192,10 +191,10 @@ my_summary{n1="val3", quantile="0.2"} 4711
   my_summary{n1="val1",n2="val2",quantile="-12.34",} NaN
 # some
 # funny comments
-# HELP 
 # HELP
+# HELP
+# HELP my_summary
 # HELP my_summary
-# HELP my_summary 
 `,
 			out: []*dto.MetricFamily{
 				{