Merge pull request #665 from prometheus/superq/revert_unexport

Arthur Silva Sens · web-flow · commit 4cf22c51d3b5 · 2024-07-15T18:01:23.000-03:00
Revert #576 and add deprecation notice
diff --git a/expfmt/decode.go b/expfmt/decode.go
@@ -45,29 +45,29 @@ func ResponseFormat(h http.Header) Format {
 
 	mediatype, params, err := mime.ParseMediaType(ct)
 	if err != nil {
-		return fmtUnknown
+		return FmtUnknown
 	}
 
 	const textType = "text/plain"
 
 	switch mediatype {
 	case ProtoType:
 		if p, ok := params["proto"]; ok && p != ProtoProtocol {
-			return fmtUnknown
+			return FmtUnknown
 		}
 		if e, ok := params["encoding"]; ok && e != "delimited" {
-			return fmtUnknown
+			return FmtUnknown
 		}
-		return fmtProtoDelim
+		return FmtProtoDelim
 
 	case textType:
 		if v, ok := params["version"]; ok && v != TextVersion {
-			return fmtUnknown
+			return FmtUnknown
 		}
-		return fmtText
+		return FmtText
 	}
 
-	return fmtUnknown
+	return FmtUnknown
 }
 
 // NewDecoder returns a new decoder based on the given input format.
diff --git a/expfmt/decode_test.go b/expfmt/decode_test.go
@@ -423,7 +423,7 @@ func TestProtoMultiMessageDecoder(t *testing.T) {
 	}
 
 	buf := bytes.NewReader(data)
-	decoder := NewDecoder(buf, fmtProtoDelim)
+	decoder := NewDecoder(buf, FmtProtoDelim)
 	var metrics []*dto.MetricFamily
 	for {
 		var mf dto.MetricFamily
@@ -448,27 +448,27 @@ func testDiscriminatorHTTPHeader(t testing.TB) {
 	}{
 		{
 			input:  map[string]string{"Content-Type": `application/vnd.google.protobuf; proto="io.prometheus.client.MetricFamily"; encoding="delimited"`},
-			output: fmtProtoDelim,
+			output: FmtProtoDelim,
 		},
 		{
 			input:  map[string]string{"Content-Type": `application/vnd.google.protobuf; proto="illegal"; encoding="delimited"`},
-			output: fmtUnknown,
+			output: FmtUnknown,
 		},
 		{
 			input:  map[string]string{"Content-Type": `application/vnd.google.protobuf; proto="io.prometheus.client.MetricFamily"; encoding="illegal"`},
-			output: fmtUnknown,
+			output: FmtUnknown,
 		},
 		{
 			input:  map[string]string{"Content-Type": `text/plain; version=0.0.4`},
-			output: fmtText,
+			output: FmtText,
 		},
 		{
 			input:  map[string]string{"Content-Type": `text/plain`},
-			output: fmtText,
+			output: FmtText,
 		},
 		{
 			input:  map[string]string{"Content-Type": `text/plain; version=0.0.3`},
-			output: fmtUnknown,
+			output: FmtUnknown,
 		},
 	}
 
@@ -574,7 +574,7 @@ func TestTextDecoderWithBufioReader(t *testing.T) {
 
 	var decoded bool
 	r := bufio.NewReader(strings.NewReader(example))
-	dec := NewDecoder(r, fmtText)
+	dec := NewDecoder(r, FmtText)
 	for {
 		var mf dto.MetricFamily
 		if err := dec.Decode(&mf); err != nil {
diff --git a/expfmt/encode.go b/expfmt/encode.go
@@ -77,18 +77,18 @@ func Negotiate(h http.Header) Format {
 		if ac.Type+"/"+ac.SubType == ProtoType && ac.Params["proto"] == ProtoProtocol {
 			switch ac.Params["encoding"] {
 			case "delimited":
-				return fmtProtoDelim + escapingScheme
+				return FmtProtoDelim + escapingScheme
 			case "text":
-				return fmtProtoText + escapingScheme
+				return FmtProtoText + escapingScheme
 			case "compact-text":
-				return fmtProtoCompact + escapingScheme
+				return FmtProtoCompact + escapingScheme
 			}
 		}
 		if ac.Type == "text" && ac.SubType == "plain" && (ver == TextVersion || ver == "") {
-			return fmtText + escapingScheme
+			return FmtText + escapingScheme
 		}
 	}
-	return fmtText + escapingScheme
+	return FmtText + escapingScheme
 }
 
 // NegotiateIncludingOpenMetrics works like Negotiate but includes
@@ -110,26 +110,26 @@ func NegotiateIncludingOpenMetrics(h http.Header) Format {
 		if ac.Type+"/"+ac.SubType == ProtoType && ac.Params["proto"] == ProtoProtocol {
 			switch ac.Params["encoding"] {
 			case "delimited":
-				return fmtProtoDelim + escapingScheme
+				return FmtProtoDelim + escapingScheme
 			case "text":
-				return fmtProtoText + escapingScheme
+				return FmtProtoText + escapingScheme
 			case "compact-text":
-				return fmtProtoCompact + escapingScheme
+				return FmtProtoCompact + escapingScheme
 			}
 		}
 		if ac.Type == "text" && ac.SubType == "plain" && (ver == TextVersion || ver == "") {
-			return fmtText + escapingScheme
+			return FmtText + escapingScheme
 		}
 		if ac.Type+"/"+ac.SubType == OpenMetricsType && (ver == OpenMetricsVersion_0_0_1 || ver == OpenMetricsVersion_1_0_0 || ver == "") {
 			switch ver {
 			case OpenMetricsVersion_1_0_0:
-				return fmtOpenMetrics_1_0_0 + escapingScheme
+				return FmtOpenMetrics_1_0_0 + escapingScheme
 			default:
-				return fmtOpenMetrics_0_0_1 + escapingScheme
+				return FmtOpenMetrics_0_0_1 + escapingScheme
 			}
 		}
 	}
-	return fmtText + escapingScheme
+	return FmtText + escapingScheme
 }
 
 // NewEncoder returns a new encoder based on content type negotiation. All
diff --git a/expfmt/encode_test.go b/expfmt/encode_test.go
@@ -222,56 +222,56 @@ func TestEncode(t *testing.T) {
 		// 1: Untyped ProtoDelim
 		{
 			metric: metric1,
-			format: fmtProtoDelim,
+			format: FmtProtoDelim,
 		},
-		// 2: Untyped fmtProtoCompact
+		// 2: Untyped FmtProtoCompact
 		{
 			metric: metric1,
-			format: fmtProtoCompact,
+			format: FmtProtoCompact,
 		},
-		// 3: Untyped fmtProtoText
+		// 3: Untyped FmtProtoText
 		{
 			metric: metric1,
-			format: fmtProtoText,
+			format: FmtProtoText,
 		},
-		// 4: Untyped fmtText
+		// 4: Untyped FmtText
 		{
 			metric: metric1,
-			format: fmtText,
+			format: FmtText,
 			expOut: `# TYPE foo_metric untyped
 foo_metric 1.234
 `,
 		},
-		// 5: Untyped fmtOpenMetrics_0_0_1
+		// 5: Untyped FmtOpenMetrics_0_0_1
 		{
 			metric: metric1,
-			format: fmtOpenMetrics_0_0_1,
+			format: FmtOpenMetrics_0_0_1,
 			expOut: `# TYPE foo_metric unknown
 foo_metric 1.234
 `,
 		},
-		// 6: Untyped fmtOpenMetrics_1_0_0
+		// 6: Untyped FmtOpenMetrics_1_0_0
 		{
 			metric: metric1,
-			format: fmtOpenMetrics_1_0_0,
+			format: FmtOpenMetrics_1_0_0,
 			expOut: `# TYPE foo_metric unknown
 foo_metric 1.234
 `,
 		},
-		// 7: Simple Counter fmtOpenMetrics_0_0_1 unit opted in
+		// 7: Simple Counter FmtOpenMetrics_0_0_1 unit opted in
 		{
 			metric:  metric1,
-			format:  fmtOpenMetrics_0_0_1,
+			format:  FmtOpenMetrics_0_0_1,
 			options: []EncoderOption{WithUnit()},
 			expOut: `# TYPE foo_metric_seconds unknown
 # UNIT foo_metric_seconds seconds
 foo_metric_seconds 1.234
 `,
 		},
-		// 8: Simple Counter fmtOpenMetrics_1_0_0 unit opted out
+		// 8: Simple Counter FmtOpenMetrics_1_0_0 unit opted out
 		{
 			metric: metric1,
-			format: fmtOpenMetrics_1_0_0,
+			format: FmtOpenMetrics_1_0_0,
 			expOut: `# TYPE foo_metric unknown
 foo_metric 1.234
 `,
@@ -310,7 +310,7 @@ foo_metric 1.234
 
 func TestEscapedEncode(t *testing.T) {
 	var buff bytes.Buffer
-	delimEncoder := NewEncoder(&buff, fmtProtoDelim+"; escaping=underscores")
+	delimEncoder := NewEncoder(&buff, FmtProtoDelim+"; escaping=underscores")
 	metric := &dto.MetricFamily{
 		Name: proto.String("foo.metric"),
 		Type: dto.MetricType_UNTYPED.Enum(),
@@ -346,7 +346,7 @@ func TestEscapedEncode(t *testing.T) {
 
 	buff.Reset()
 
-	compactEncoder := NewEncoder(&buff, fmtProtoCompact)
+	compactEncoder := NewEncoder(&buff, FmtProtoCompact)
 	err = compactEncoder.Encode(metric)
 	if err != nil {
 		t.Errorf("unexpected error during encode: %s", err.Error())
@@ -359,7 +359,7 @@ func TestEscapedEncode(t *testing.T) {
 
 	buff.Reset()
 
-	protoTextEncoder := NewEncoder(&buff, fmtProtoText)
+	protoTextEncoder := NewEncoder(&buff, FmtProtoText)
 	err = protoTextEncoder.Encode(metric)
 	if err != nil {
 		t.Errorf("unexpected error during encode: %s", err.Error())
@@ -372,7 +372,7 @@ func TestEscapedEncode(t *testing.T) {
 
 	buff.Reset()
 
-	textEncoder := NewEncoder(&buff, fmtText)
+	textEncoder := NewEncoder(&buff, FmtText)
 	err = textEncoder.Encode(metric)
 	if err != nil {
 		t.Errorf("unexpected error during encode: %s", err.Error())
diff --git a/expfmt/expfmt.go b/expfmt/expfmt.go
@@ -32,24 +32,31 @@ type Format string
 // it on the wire, new content-type strings will have to be agreed upon and
 // added here.
 const (
-	TextVersion              = "0.0.4"
-	ProtoType                = `application/vnd.google.protobuf`
-	ProtoProtocol            = `io.prometheus.client.MetricFamily`
-	protoFmt                 = ProtoType + "; proto=" + ProtoProtocol + ";"
+	TextVersion   = "0.0.4"
+	ProtoType     = `application/vnd.google.protobuf`
+	ProtoProtocol = `io.prometheus.client.MetricFamily`
+	// Deprecated: Use expfmt.NewFormat(expfmt.TypeProtoCompact) instead.
+	ProtoFmt                 = ProtoType + "; proto=" + ProtoProtocol + ";"
 	OpenMetricsType          = `application/openmetrics-text`
 	OpenMetricsVersion_0_0_1 = "0.0.1"
 	OpenMetricsVersion_1_0_0 = "1.0.0"
 
-	// The Content-Type values for the different wire protocols. Note that these
-	// values are now unexported. If code was relying on comparisons to these
-	// constants, instead use FormatType().
-	fmtUnknown           Format = `<unknown>`
-	fmtText              Format = `text/plain; version=` + TextVersion + `; charset=utf-8`
-	fmtProtoDelim        Format = protoFmt + ` encoding=delimited`
-	fmtProtoText         Format = protoFmt + ` encoding=text`
-	fmtProtoCompact      Format = protoFmt + ` encoding=compact-text`
-	fmtOpenMetrics_1_0_0 Format = OpenMetricsType + `; version=` + OpenMetricsVersion_1_0_0 + `; charset=utf-8`
-	fmtOpenMetrics_0_0_1 Format = OpenMetricsType + `; version=` + OpenMetricsVersion_0_0_1 + `; charset=utf-8`
+	// The Content-Type values for the different wire protocols. Do not do direct
+	// comparisons to these constants, instead use the comparison functions.
+	// Deprecated: Use expfmt.NewFormat(expfmt.TypeUnknown) instead.
+	FmtUnknown Format = `<unknown>`
+	// Deprecated: Use expfmt.NewFormat(expfmt.TypeTextPlain) instead.
+	FmtText Format = `text/plain; version=` + TextVersion + `; charset=utf-8`
+	// Deprecated: Use expfmt.NewFormat(expfmt.TypeProtoDelim) instead.
+	FmtProtoDelim Format = ProtoFmt + ` encoding=delimited`
+	// Deprecated: Use expfmt.NewFormat(expfmt.TypeProtoText) instead.
+	FmtProtoText Format = ProtoFmt + ` encoding=text`
+	// Deprecated: Use expfmt.NewFormat(expfmt.TypeProtoCompact) instead.
+	FmtProtoCompact Format = ProtoFmt + ` encoding=compact-text`
+	// Deprecated: Use expfmt.NewFormat(expfmt.TypeOpenMetrics) instead.
+	FmtOpenMetrics_1_0_0 Format = OpenMetricsType + `; version=` + OpenMetricsVersion_1_0_0 + `; charset=utf-8`
+	// Deprecated: Use expfmt.NewFormat(expfmt.TypeOpenMetrics) instead.
+	FmtOpenMetrics_0_0_1 Format = OpenMetricsType + `; version=` + OpenMetricsVersion_0_0_1 + `; charset=utf-8`
 )
 
 const (
@@ -79,30 +86,30 @@ const (
 func NewFormat(t FormatType) Format {
 	switch t {
 	case TypeProtoCompact:
-		return fmtProtoCompact
+		return FmtProtoCompact
 	case TypeProtoDelim:
-		return fmtProtoDelim
+		return FmtProtoDelim
 	case TypeProtoText:
-		return fmtProtoText
+		return FmtProtoText
 	case TypeTextPlain:
-		return fmtText
+		return FmtText
 	case TypeOpenMetrics:
-		return fmtOpenMetrics_1_0_0
+		return FmtOpenMetrics_1_0_0
 	default:
-		return fmtUnknown
+		return FmtUnknown
 	}
 }
 
 // NewOpenMetricsFormat generates a new OpenMetrics format matching the
 // specified version number.
 func NewOpenMetricsFormat(version string) (Format, error) {
 	if version == OpenMetricsVersion_0_0_1 {
-		return fmtOpenMetrics_0_0_1, nil
+		return FmtOpenMetrics_0_0_1, nil
 	}
 	if version == OpenMetricsVersion_1_0_0 {
-		return fmtOpenMetrics_1_0_0, nil
+		return FmtOpenMetrics_1_0_0, nil
 	}
-	return fmtUnknown, fmt.Errorf("unknown open metrics version string")
+	return FmtUnknown, fmt.Errorf("unknown open metrics version string")
 }
 
 // FormatType deduces an overall FormatType for the given format.
diff --git a/expfmt/expfmt_test.go b/expfmt/expfmt_test.go
@@ -28,27 +28,27 @@ func TestToFormatType(t *testing.T) {
 		expected FormatType
 	}{
 		{
-			format:   fmtProtoCompact,
+			format:   FmtProtoCompact,
 			expected: TypeProtoCompact,
 		},
 		{
-			format:   fmtProtoDelim,
+			format:   FmtProtoDelim,
 			expected: TypeProtoDelim,
 		},
 		{
-			format:   fmtProtoText,
+			format:   FmtProtoText,
 			expected: TypeProtoText,
 		},
 		{
-			format:   fmtOpenMetrics_1_0_0,
+			format:   FmtOpenMetrics_1_0_0,
 			expected: TypeOpenMetrics,
 		},
 		{
-			format:   fmtText,
+			format:   FmtText,
 			expected: TypeTextPlain,
 		},
 		{
-			format:   fmtOpenMetrics_0_0_1,
+			format:   FmtOpenMetrics_0_0_1,
 			expected: TypeOpenMetrics,
 		},
 		{
@@ -104,7 +104,7 @@ func TestToEscapingScheme(t *testing.T) {
 		expected model.EscapingScheme
 	}{
 		{
-			format:   fmtProtoCompact,
+			format:   FmtProtoCompact,
 			expected: model.ValueEncodingEscaping,
 		},
 		{

Original file line number	Diff line number	Diff line change
`@@ -45,29 +45,29 @@ func ResponseFormat(h http.Header) Format {`
`45`	`45`
`46`	`46`	`mediatype, params, err := mime.ParseMediaType(ct)`
`47`	`47`	`if err != nil {`
`48`		`- return fmtUnknown`
	`48`	`+ return FmtUnknown`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`const textType = "text/plain"`
`52`	`52`
`53`	`53`	`switch mediatype {`
`54`	`54`	`case ProtoType:`
`55`	`55`	`if p, ok := params["proto"]; ok && p != ProtoProtocol {`
`56`		`- return fmtUnknown`
	`56`	`+ return FmtUnknown`
`57`	`57`	`}`
`58`	`58`	`if e, ok := params["encoding"]; ok && e != "delimited" {`
`59`		`- return fmtUnknown`
	`59`	`+ return FmtUnknown`
`60`	`60`	`}`
`61`		`- return fmtProtoDelim`
	`61`	`+ return FmtProtoDelim`
`62`	`62`
`63`	`63`	`case textType:`
`64`	`64`	`if v, ok := params["version"]; ok && v != TextVersion {`
`65`		`- return fmtUnknown`
	`65`	`+ return FmtUnknown`
`66`	`66`	`}`
`67`		`- return fmtText`
	`67`	`+ return FmtText`
`68`	`68`	`}`
`69`	`69`
`70`		`- return fmtUnknown`
	`70`	`+ return FmtUnknown`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`// NewDecoder returns a new decoder based on the given input format.`
Original file line number	Diff line number	Diff line change
`@@ -77,18 +77,18 @@ func Negotiate(h http.Header) Format {`
`77`	`77`	`if ac.Type+"/"+ac.SubType == ProtoType && ac.Params["proto"] == ProtoProtocol {`
`78`	`78`	`switch ac.Params["encoding"] {`
`79`	`79`	`case "delimited":`
`80`		`- return fmtProtoDelim + escapingScheme`
	`80`	`+ return FmtProtoDelim + escapingScheme`
`81`	`81`	`case "text":`
`82`		`- return fmtProtoText + escapingScheme`
	`82`	`+ return FmtProtoText + escapingScheme`
`83`	`83`	`case "compact-text":`
`84`		`- return fmtProtoCompact + escapingScheme`
	`84`	`+ return FmtProtoCompact + escapingScheme`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`	`if ac.Type == "text" && ac.SubType == "plain" && (ver == TextVersion \|\| ver == "") {`
`88`		`- return fmtText + escapingScheme`
	`88`	`+ return FmtText + escapingScheme`
`89`	`89`	`}`
`90`	`90`	`}`
`91`		`- return fmtText + escapingScheme`
	`91`	`+ return FmtText + escapingScheme`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`// NegotiateIncludingOpenMetrics works like Negotiate but includes`
`@@ -110,26 +110,26 @@ func NegotiateIncludingOpenMetrics(h http.Header) Format {`
`110`	`110`	`if ac.Type+"/"+ac.SubType == ProtoType && ac.Params["proto"] == ProtoProtocol {`
`111`	`111`	`switch ac.Params["encoding"] {`
`112`	`112`	`case "delimited":`
`113`		`- return fmtProtoDelim + escapingScheme`
	`113`	`+ return FmtProtoDelim + escapingScheme`
`114`	`114`	`case "text":`
`115`		`- return fmtProtoText + escapingScheme`
	`115`	`+ return FmtProtoText + escapingScheme`
`116`	`116`	`case "compact-text":`
`117`		`- return fmtProtoCompact + escapingScheme`
	`117`	`+ return FmtProtoCompact + escapingScheme`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`	`if ac.Type == "text" && ac.SubType == "plain" && (ver == TextVersion \|\| ver == "") {`
`121`		`- return fmtText + escapingScheme`
	`121`	`+ return FmtText + escapingScheme`
`122`	`122`	`}`
`123`	`123`	`if ac.Type+"/"+ac.SubType == OpenMetricsType && (ver == OpenMetricsVersion_0_0_1 \|\| ver == OpenMetricsVersion_1_0_0 \|\| ver == "") {`
`124`	`124`	`switch ver {`
`125`	`125`	`case OpenMetricsVersion_1_0_0:`
`126`		`- return fmtOpenMetrics_1_0_0 + escapingScheme`
	`126`	`+ return FmtOpenMetrics_1_0_0 + escapingScheme`
`127`	`127`	`default:`
`128`		`- return fmtOpenMetrics_0_0_1 + escapingScheme`
	`128`	`+ return FmtOpenMetrics_0_0_1 + escapingScheme`
`129`	`129`	`}`
`130`	`130`	`}`
`131`	`131`	`}`
`132`		`- return fmtText + escapingScheme`
	`132`	`+ return FmtText + escapingScheme`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`// NewEncoder returns a new encoder based on content type negotiation. All`
Original file line number	Diff line number	Diff line change
`@@ -28,27 +28,27 @@ func TestToFormatType(t *testing.T) {`
`28`	`28`	`expected FormatType`
`29`	`29`	`}{`
`30`	`30`	`{`
`31`		`- format: fmtProtoCompact,`
	`31`	`+ format: FmtProtoCompact,`
`32`	`32`	`expected: TypeProtoCompact,`
`33`	`33`	`},`
`34`	`34`	`{`
`35`		`- format: fmtProtoDelim,`
	`35`	`+ format: FmtProtoDelim,`
`36`	`36`	`expected: TypeProtoDelim,`
`37`	`37`	`},`
`38`	`38`	`{`
`39`		`- format: fmtProtoText,`
	`39`	`+ format: FmtProtoText,`
`40`	`40`	`expected: TypeProtoText,`
`41`	`41`	`},`
`42`	`42`	`{`
`43`		`- format: fmtOpenMetrics_1_0_0,`
	`43`	`+ format: FmtOpenMetrics_1_0_0,`
`44`	`44`	`expected: TypeOpenMetrics,`
`45`	`45`	`},`
`46`	`46`	`{`
`47`		`- format: fmtText,`
	`47`	`+ format: FmtText,`
`48`	`48`	`expected: TypeTextPlain,`
`49`	`49`	`},`
`50`	`50`	`{`
`51`		`- format: fmtOpenMetrics_0_0_1,`
	`51`	`+ format: FmtOpenMetrics_0_0_1,`
`52`	`52`	`expected: TypeOpenMetrics,`
`53`	`53`	`},`
`54`	`54`	`{`
`@@ -104,7 +104,7 @@ func TestToEscapingScheme(t *testing.T) {`
`104`	`104`	`expected model.EscapingScheme`
`105`	`105`	`}{`
`106`	`106`	`{`
`107`		`- format: fmtProtoCompact,`
	`107`	`+ format: FmtProtoCompact,`
`108`	`108`	`expected: model.ValueEncodingEscaping,`
`109`	`109`	`},`
`110`	`110`	`{`