cubefs

1
// Copyright 2014 The Prometheus Authors
2
// Licensed under the Apache License, Version 2.0 (the "License");
3
// you may not use this file except in compliance with the License.
4
// You may obtain a copy of the License at
5
//
6
// http://www.apache.org/licenses/LICENSE-2.0
7
//
8
// Unless required by applicable law or agreed to in writing, software
9
// distributed under the License is distributed on an "AS IS" BASIS,
10
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11
// See the License for the specific language governing permissions and
12
// limitations under the License.
13

14
package expfmt
15

16
import (
17
	"bufio"
18
	"bytes"
19
	"fmt"
20
	"io"
21
	"math"
22
	"strconv"
23
	"strings"
24

25
	dto "github.com/prometheus/client_model/go"
26

27
	"github.com/golang/protobuf/proto" //nolint:staticcheck // Ignore SA1019. Need to keep deprecated package for compatibility.
28
	"github.com/prometheus/common/model"
29
)
30

31
// A stateFn is a function that represents a state in a state machine. By
32
// executing it, the state is progressed to the next state. The stateFn returns
33
// another stateFn, which represents the new state. The end state is represented
34
// by nil.
35
type stateFn func() stateFn
36

37
// ParseError signals errors while parsing the simple and flat text-based
38
// exchange format.
39
type ParseError struct {
40
	Line int
41
	Msg  string
42
}
43

44
// Error implements the error interface.
45
func (e ParseError) Error() string {
46
	return fmt.Sprintf("text format parsing error in line %d: %s", e.Line, e.Msg)
47
}
48

49
// TextParser is used to parse the simple and flat text-based exchange format. Its
50
// zero value is ready to use.
51
type TextParser struct {
52
	metricFamiliesByName map[string]*dto.MetricFamily
53
	buf                  *bufio.Reader // Where the parsed input is read through.
54
	err                  error         // Most recent error.
55
	lineCount            int           // Tracks the line count for error messages.
56
	currentByte          byte          // The most recent byte read.
57
	currentToken         bytes.Buffer  // Re-used each time a token has to be gathered from multiple bytes.
58
	currentMF            *dto.MetricFamily
59
	currentMetric        *dto.Metric
60
	currentLabelPair     *dto.LabelPair
61

62
	// The remaining member variables are only used for summaries/histograms.
63
	currentLabels map[string]string // All labels including '__name__' but excluding 'quantile'/'le'
64
	// Summary specific.
65
	summaries       map[uint64]*dto.Metric // Key is created with LabelsToSignature.
66
	currentQuantile float64
67
	// Histogram specific.
68
	histograms    map[uint64]*dto.Metric // Key is created with LabelsToSignature.
69
	currentBucket float64
70
	// These tell us if the currently processed line ends on '_count' or
71
	// '_sum' respectively and belong to a summary/histogram, representing the sample
72
	// count and sum of that summary/histogram.
73
	currentIsSummaryCount, currentIsSummarySum     bool
74
	currentIsHistogramCount, currentIsHistogramSum bool
75
}
76

77
// TextToMetricFamilies reads 'in' as the simple and flat text-based exchange
78
// format and creates MetricFamily proto messages. It returns the MetricFamily
79
// proto messages in a map where the metric names are the keys, along with any
80
// error encountered.
81
//
82
// If the input contains duplicate metrics (i.e. lines with the same metric name
83
// and exactly the same label set), the resulting MetricFamily will contain
84
// duplicate Metric proto messages. Similar is true for duplicate label
85
// names. Checks for duplicates have to be performed separately, if required.
86
// Also note that neither the metrics within each MetricFamily are sorted nor
87
// the label pairs within each Metric. Sorting is not required for the most
88
// frequent use of this method, which is sample ingestion in the Prometheus
89
// server. However, for presentation purposes, you might want to sort the
90
// metrics, and in some cases, you must sort the labels, e.g. for consumption by
91
// the metric family injection hook of the Prometheus registry.
92
//
93
// Summaries and histograms are rather special beasts. You would probably not
94
// use them in the simple text format anyway. This method can deal with
95
// summaries and histograms if they are presented in exactly the way the
96
// text.Create function creates them.
97
//
98
// This method must not be called concurrently. If you want to parse different
99
// input concurrently, instantiate a separate Parser for each goroutine.
100
func (p *TextParser) TextToMetricFamilies(in io.Reader) (map[string]*dto.MetricFamily, error) {
101
	p.reset(in)
102
	for nextState := p.startOfLine; nextState != nil; nextState = nextState() {
103
		// Magic happens here...
104
	}
105
	// Get rid of empty metric families.
106
	for k, mf := range p.metricFamiliesByName {
107
		if len(mf.GetMetric()) == 0 {
108
			delete(p.metricFamiliesByName, k)
109
		}
110
	}
111
	// If p.err is io.EOF now, we have run into a premature end of the input
112
	// stream. Turn this error into something nicer and more
113
	// meaningful. (io.EOF is often used as a signal for the legitimate end
114
	// of an input stream.)
115
	if p.err == io.EOF {
116
		p.parseError("unexpected end of input stream")
117
	}
118
	return p.metricFamiliesByName, p.err
119
}
120

121
func (p *TextParser) reset(in io.Reader) {
122
	p.metricFamiliesByName = map[string]*dto.MetricFamily{}
123
	if p.buf == nil {
124
		p.buf = bufio.NewReader(in)
125
	} else {
126
		p.buf.Reset(in)
127
	}
128
	p.err = nil
129
	p.lineCount = 0
130
	if p.summaries == nil || len(p.summaries) > 0 {
131
		p.summaries = map[uint64]*dto.Metric{}
132
	}
133
	if p.histograms == nil || len(p.histograms) > 0 {
134
		p.histograms = map[uint64]*dto.Metric{}
135
	}
136
	p.currentQuantile = math.NaN()
137
	p.currentBucket = math.NaN()
138
}
139

140
// startOfLine represents the state where the next byte read from p.buf is the
141
// start of a line (or whitespace leading up to it).
142
func (p *TextParser) startOfLine() stateFn {
143
	p.lineCount++
144
	if p.skipBlankTab(); p.err != nil {
145
		// End of input reached. This is the only case where
146
		// that is not an error but a signal that we are done.
147
		p.err = nil
148
		return nil
149
	}
150
	switch p.currentByte {
151
	case '#':
152
		return p.startComment
153
	case '\n':
154
		return p.startOfLine // Empty line, start the next one.
155
	}
156
	return p.readingMetricName
157
}
158

159
// startComment represents the state where the next byte read from p.buf is the
160
// start of a comment (or whitespace leading up to it).
161
func (p *TextParser) startComment() stateFn {
162
	if p.skipBlankTab(); p.err != nil {
163
		return nil // Unexpected end of input.
164
	}
165
	if p.currentByte == '\n' {
166
		return p.startOfLine
167
	}
168
	if p.readTokenUntilWhitespace(); p.err != nil {
169
		return nil // Unexpected end of input.
170
	}
171
	// If we have hit the end of line already, there is nothing left
172
	// to do. This is not considered a syntax error.
173
	if p.currentByte == '\n' {
174
		return p.startOfLine
175
	}
176
	keyword := p.currentToken.String()
177
	if keyword != "HELP" && keyword != "TYPE" {
178
		// Generic comment, ignore by fast forwarding to end of line.
179
		for p.currentByte != '\n' {
180
			if p.currentByte, p.err = p.buf.ReadByte(); p.err != nil {
181
				return nil // Unexpected end of input.
182
			}
183
		}
184
		return p.startOfLine
185
	}
186
	// There is something. Next has to be a metric name.
187
	if p.skipBlankTab(); p.err != nil {
188
		return nil // Unexpected end of input.
189
	}
190
	if p.readTokenAsMetricName(); p.err != nil {
191
		return nil // Unexpected end of input.
192
	}
193
	if p.currentByte == '\n' {
194
		// At the end of the line already.
195
		// Again, this is not considered a syntax error.
196
		return p.startOfLine
197
	}
198
	if !isBlankOrTab(p.currentByte) {
199
		p.parseError("invalid metric name in comment")
200
		return nil
201
	}
202
	p.setOrCreateCurrentMF()
203
	if p.skipBlankTab(); p.err != nil {
204
		return nil // Unexpected end of input.
205
	}
206
	if p.currentByte == '\n' {
207
		// At the end of the line already.
208
		// Again, this is not considered a syntax error.
209
		return p.startOfLine
210
	}
211
	switch keyword {
212
	case "HELP":
213
		return p.readingHelp
214
	case "TYPE":
215
		return p.readingType
216
	}
217
	panic(fmt.Sprintf("code error: unexpected keyword %q", keyword))
218
}
219

220
// readingMetricName represents the state where the last byte read (now in
221
// p.currentByte) is the first byte of a metric name.
222
func (p *TextParser) readingMetricName() stateFn {
223
	if p.readTokenAsMetricName(); p.err != nil {
224
		return nil
225
	}
226
	if p.currentToken.Len() == 0 {
227
		p.parseError("invalid metric name")
228
		return nil
229
	}
230
	p.setOrCreateCurrentMF()
231
	// Now is the time to fix the type if it hasn't happened yet.
232
	if p.currentMF.Type == nil {
233
		p.currentMF.Type = dto.MetricType_UNTYPED.Enum()
234
	}
235
	p.currentMetric = &dto.Metric{}
236
	// Do not append the newly created currentMetric to
237
	// currentMF.Metric right now. First wait if this is a summary,
238
	// and the metric exists already, which we can only know after
239
	// having read all the labels.
240
	if p.skipBlankTabIfCurrentBlankTab(); p.err != nil {
241
		return nil // Unexpected end of input.
242
	}
243
	return p.readingLabels
244
}
245

246
// readingLabels represents the state where the last byte read (now in
247
// p.currentByte) is either the first byte of the label set (i.e. a '{'), or the
248
// first byte of the value (otherwise).
249
func (p *TextParser) readingLabels() stateFn {
250
	// Summaries/histograms are special. We have to reset the
251
	// currentLabels map, currentQuantile and currentBucket before starting to
252
	// read labels.
253
	if p.currentMF.GetType() == dto.MetricType_SUMMARY || p.currentMF.GetType() == dto.MetricType_HISTOGRAM {
254
		p.currentLabels = map[string]string{}
255
		p.currentLabels[string(model.MetricNameLabel)] = p.currentMF.GetName()
256
		p.currentQuantile = math.NaN()
257
		p.currentBucket = math.NaN()
258
	}
259
	if p.currentByte != '{' {
260
		return p.readingValue
261
	}
262
	return p.startLabelName
263
}
264

265
// startLabelName represents the state where the next byte read from p.buf is
266
// the start of a label name (or whitespace leading up to it).
267
func (p *TextParser) startLabelName() stateFn {
268
	if p.skipBlankTab(); p.err != nil {
269
		return nil // Unexpected end of input.
270
	}
271
	if p.currentByte == '}' {
272
		if p.skipBlankTab(); p.err != nil {
273
			return nil // Unexpected end of input.
274
		}
275
		return p.readingValue
276
	}
277
	if p.readTokenAsLabelName(); p.err != nil {
278
		return nil // Unexpected end of input.
279
	}
280
	if p.currentToken.Len() == 0 {
281
		p.parseError(fmt.Sprintf("invalid label name for metric %q", p.currentMF.GetName()))
282
		return nil
283
	}
284
	p.currentLabelPair = &dto.LabelPair{Name: proto.String(p.currentToken.String())}
285
	if p.currentLabelPair.GetName() == string(model.MetricNameLabel) {
286
		p.parseError(fmt.Sprintf("label name %q is reserved", model.MetricNameLabel))
287
		return nil
288
	}
289
	// Special summary/histogram treatment. Don't add 'quantile' and 'le'
290
	// labels to 'real' labels.
291
	if !(p.currentMF.GetType() == dto.MetricType_SUMMARY && p.currentLabelPair.GetName() == model.QuantileLabel) &&
292
		!(p.currentMF.GetType() == dto.MetricType_HISTOGRAM && p.currentLabelPair.GetName() == model.BucketLabel) {
293
		p.currentMetric.Label = append(p.currentMetric.Label, p.currentLabelPair)
294
	}
295
	if p.skipBlankTabIfCurrentBlankTab(); p.err != nil {
296
		return nil // Unexpected end of input.
297
	}
298
	if p.currentByte != '=' {
299
		p.parseError(fmt.Sprintf("expected '=' after label name, found %q", p.currentByte))
300
		return nil
301
	}
302
	// Check for duplicate label names.
303
	labels := make(map[string]struct{})
304
	for _, l := range p.currentMetric.Label {
305
		lName := l.GetName()
306
		if _, exists := labels[lName]; !exists {
307
			labels[lName] = struct{}{}
308
		} else {
309
			p.parseError(fmt.Sprintf("duplicate label names for metric %q", p.currentMF.GetName()))
310
			return nil
311
		}
312
	}
313
	return p.startLabelValue
314
}
315

316
// startLabelValue represents the state where the next byte read from p.buf is
317
// the start of a (quoted) label value (or whitespace leading up to it).
318
func (p *TextParser) startLabelValue() stateFn {
319
	if p.skipBlankTab(); p.err != nil {
320
		return nil // Unexpected end of input.
321
	}
322
	if p.currentByte != '"' {
323
		p.parseError(fmt.Sprintf("expected '\"' at start of label value, found %q", p.currentByte))
324
		return nil
325
	}
326
	if p.readTokenAsLabelValue(); p.err != nil {
327
		return nil
328
	}
329
	if !model.LabelValue(p.currentToken.String()).IsValid() {
330
		p.parseError(fmt.Sprintf("invalid label value %q", p.currentToken.String()))
331
		return nil
332
	}
333
	p.currentLabelPair.Value = proto.String(p.currentToken.String())
334
	// Special treatment of summaries:
335
	// - Quantile labels are special, will result in dto.Quantile later.
336
	// - Other labels have to be added to currentLabels for signature calculation.
337
	if p.currentMF.GetType() == dto.MetricType_SUMMARY {
338
		if p.currentLabelPair.GetName() == model.QuantileLabel {
339
			if p.currentQuantile, p.err = parseFloat(p.currentLabelPair.GetValue()); p.err != nil {
340
				// Create a more helpful error message.
341
				p.parseError(fmt.Sprintf("expected float as value for 'quantile' label, got %q", p.currentLabelPair.GetValue()))
342
				return nil
343
			}
344
		} else {
345
			p.currentLabels[p.currentLabelPair.GetName()] = p.currentLabelPair.GetValue()
346
		}
347
	}
348
	// Similar special treatment of histograms.
349
	if p.currentMF.GetType() == dto.MetricType_HISTOGRAM {
350
		if p.currentLabelPair.GetName() == model.BucketLabel {
351
			if p.currentBucket, p.err = parseFloat(p.currentLabelPair.GetValue()); p.err != nil {
352
				// Create a more helpful error message.
353
				p.parseError(fmt.Sprintf("expected float as value for 'le' label, got %q", p.currentLabelPair.GetValue()))
354
				return nil
355
			}
356
		} else {
357
			p.currentLabels[p.currentLabelPair.GetName()] = p.currentLabelPair.GetValue()
358
		}
359
	}
360
	if p.skipBlankTab(); p.err != nil {
361
		return nil // Unexpected end of input.
362
	}
363
	switch p.currentByte {
364
	case ',':
365
		return p.startLabelName
366

367
	case '}':
368
		if p.skipBlankTab(); p.err != nil {
369
			return nil // Unexpected end of input.
370
		}
371
		return p.readingValue
372
	default:
373
		p.parseError(fmt.Sprintf("unexpected end of label value %q", p.currentLabelPair.GetValue()))
374
		return nil
375
	}
376
}
377

378
// readingValue represents the state where the last byte read (now in
379
// p.currentByte) is the first byte of the sample value (i.e. a float).
380
func (p *TextParser) readingValue() stateFn {
381
	// When we are here, we have read all the labels, so for the
382
	// special case of a summary/histogram, we can finally find out
383
	// if the metric already exists.
384
	if p.currentMF.GetType() == dto.MetricType_SUMMARY {
385
		signature := model.LabelsToSignature(p.currentLabels)
386
		if summary := p.summaries[signature]; summary != nil {
387
			p.currentMetric = summary
388
		} else {
389
			p.summaries[signature] = p.currentMetric
390
			p.currentMF.Metric = append(p.currentMF.Metric, p.currentMetric)
391
		}
392
	} else if p.currentMF.GetType() == dto.MetricType_HISTOGRAM {
393
		signature := model.LabelsToSignature(p.currentLabels)
394
		if histogram := p.histograms[signature]; histogram != nil {
395
			p.currentMetric = histogram
396
		} else {
397
			p.histograms[signature] = p.currentMetric
398
			p.currentMF.Metric = append(p.currentMF.Metric, p.currentMetric)
399
		}
400
	} else {
401
		p.currentMF.Metric = append(p.currentMF.Metric, p.currentMetric)
402
	}
403
	if p.readTokenUntilWhitespace(); p.err != nil {
404
		return nil // Unexpected end of input.
405
	}
406
	value, err := parseFloat(p.currentToken.String())
407
	if err != nil {
408
		// Create a more helpful error message.
409
		p.parseError(fmt.Sprintf("expected float as value, got %q", p.currentToken.String()))
410
		return nil
411
	}
412
	switch p.currentMF.GetType() {
413
	case dto.MetricType_COUNTER:
414
		p.currentMetric.Counter = &dto.Counter{Value: proto.Float64(value)}
415
	case dto.MetricType_GAUGE:
416
		p.currentMetric.Gauge = &dto.Gauge{Value: proto.Float64(value)}
417
	case dto.MetricType_UNTYPED:
418
		p.currentMetric.Untyped = &dto.Untyped{Value: proto.Float64(value)}
419
	case dto.MetricType_SUMMARY:
420
		// *sigh*
421
		if p.currentMetric.Summary == nil {
422
			p.currentMetric.Summary = &dto.Summary{}
423
		}
424
		switch {
425
		case p.currentIsSummaryCount:
426
			p.currentMetric.Summary.SampleCount = proto.Uint64(uint64(value))
427
		case p.currentIsSummarySum:
428
			p.currentMetric.Summary.SampleSum = proto.Float64(value)
429
		case !math.IsNaN(p.currentQuantile):
430
			p.currentMetric.Summary.Quantile = append(
431
				p.currentMetric.Summary.Quantile,
432
				&dto.Quantile{
433
					Quantile: proto.Float64(p.currentQuantile),
434
					Value:    proto.Float64(value),
435
				},
436
			)
437
		}
438
	case dto.MetricType_HISTOGRAM:
439
		// *sigh*
440
		if p.currentMetric.Histogram == nil {
441
			p.currentMetric.Histogram = &dto.Histogram{}
442
		}
443
		switch {
444
		case p.currentIsHistogramCount:
445
			p.currentMetric.Histogram.SampleCount = proto.Uint64(uint64(value))
446
		case p.currentIsHistogramSum:
447
			p.currentMetric.Histogram.SampleSum = proto.Float64(value)
448
		case !math.IsNaN(p.currentBucket):
449
			p.currentMetric.Histogram.Bucket = append(
450
				p.currentMetric.Histogram.Bucket,
451
				&dto.Bucket{
452
					UpperBound:      proto.Float64(p.currentBucket),
453
					CumulativeCount: proto.Uint64(uint64(value)),
454
				},
455
			)
456
		}
457
	default:
458
		p.err = fmt.Errorf("unexpected type for metric name %q", p.currentMF.GetName())
459
	}
460
	if p.currentByte == '\n' {
461
		return p.startOfLine
462
	}
463
	return p.startTimestamp
464
}
465

466
// startTimestamp represents the state where the next byte read from p.buf is
467
// the start of the timestamp (or whitespace leading up to it).
468
func (p *TextParser) startTimestamp() stateFn {
469
	if p.skipBlankTab(); p.err != nil {
470
		return nil // Unexpected end of input.
471
	}
472
	if p.readTokenUntilWhitespace(); p.err != nil {
473
		return nil // Unexpected end of input.
474
	}
475
	timestamp, err := strconv.ParseInt(p.currentToken.String(), 10, 64)
476
	if err != nil {
477
		// Create a more helpful error message.
478
		p.parseError(fmt.Sprintf("expected integer as timestamp, got %q", p.currentToken.String()))
479
		return nil
480
	}
481
	p.currentMetric.TimestampMs = proto.Int64(timestamp)
482
	if p.readTokenUntilNewline(false); p.err != nil {
483
		return nil // Unexpected end of input.
484
	}
485
	if p.currentToken.Len() > 0 {
486
		p.parseError(fmt.Sprintf("spurious string after timestamp: %q", p.currentToken.String()))
487
		return nil
488
	}
489
	return p.startOfLine
490
}
491

492
// readingHelp represents the state where the last byte read (now in
493
// p.currentByte) is the first byte of the docstring after 'HELP'.
494
func (p *TextParser) readingHelp() stateFn {
495
	if p.currentMF.Help != nil {
496
		p.parseError(fmt.Sprintf("second HELP line for metric name %q", p.currentMF.GetName()))
497
		return nil
498
	}
499
	// Rest of line is the docstring.
500
	if p.readTokenUntilNewline(true); p.err != nil {
501
		return nil // Unexpected end of input.
502
	}
503
	p.currentMF.Help = proto.String(p.currentToken.String())
504
	return p.startOfLine
505
}
506

507
// readingType represents the state where the last byte read (now in
508
// p.currentByte) is the first byte of the type hint after 'HELP'.
509
func (p *TextParser) readingType() stateFn {
510
	if p.currentMF.Type != nil {
511
		p.parseError(fmt.Sprintf("second TYPE line for metric name %q, or TYPE reported after samples", p.currentMF.GetName()))
512
		return nil
513
	}
514
	// Rest of line is the type.
515
	if p.readTokenUntilNewline(false); p.err != nil {
516
		return nil // Unexpected end of input.
517
	}
518
	metricType, ok := dto.MetricType_value[strings.ToUpper(p.currentToken.String())]
519
	if !ok {
520
		p.parseError(fmt.Sprintf("unknown metric type %q", p.currentToken.String()))
521
		return nil
522
	}
523
	p.currentMF.Type = dto.MetricType(metricType).Enum()
524
	return p.startOfLine
525
}
526

527
// parseError sets p.err to a ParseError at the current line with the given
528
// message.
529
func (p *TextParser) parseError(msg string) {
530
	p.err = ParseError{
531
		Line: p.lineCount,
532
		Msg:  msg,
533
	}
534
}
535

536
// skipBlankTab reads (and discards) bytes from p.buf until it encounters a byte
537
// that is neither ' ' nor '\t'. That byte is left in p.currentByte.
538
func (p *TextParser) skipBlankTab() {
539
	for {
540
		if p.currentByte, p.err = p.buf.ReadByte(); p.err != nil || !isBlankOrTab(p.currentByte) {
541
			return
542
		}
543
	}
544
}
545

546
// skipBlankTabIfCurrentBlankTab works exactly as skipBlankTab but doesn't do
547
// anything if p.currentByte is neither ' ' nor '\t'.
548
func (p *TextParser) skipBlankTabIfCurrentBlankTab() {
549
	if isBlankOrTab(p.currentByte) {
550
		p.skipBlankTab()
551
	}
552
}
553

554
// readTokenUntilWhitespace copies bytes from p.buf into p.currentToken.  The
555
// first byte considered is the byte already read (now in p.currentByte).  The
556
// first whitespace byte encountered is still copied into p.currentByte, but not
557
// into p.currentToken.
558
func (p *TextParser) readTokenUntilWhitespace() {
559
	p.currentToken.Reset()
560
	for p.err == nil && !isBlankOrTab(p.currentByte) && p.currentByte != '\n' {
561
		p.currentToken.WriteByte(p.currentByte)
562
		p.currentByte, p.err = p.buf.ReadByte()
563
	}
564
}
565

566
// readTokenUntilNewline copies bytes from p.buf into p.currentToken.  The first
567
// byte considered is the byte already read (now in p.currentByte).  The first
568
// newline byte encountered is still copied into p.currentByte, but not into
569
// p.currentToken. If recognizeEscapeSequence is true, two escape sequences are
570
// recognized: '\\' translates into '\', and '\n' into a line-feed character.
571
// All other escape sequences are invalid and cause an error.
572
func (p *TextParser) readTokenUntilNewline(recognizeEscapeSequence bool) {
573
	p.currentToken.Reset()
574
	escaped := false
575
	for p.err == nil {
576
		if recognizeEscapeSequence && escaped {
577
			switch p.currentByte {
578
			case '\\':
579
				p.currentToken.WriteByte(p.currentByte)
580
			case 'n':
581
				p.currentToken.WriteByte('\n')
582
			default:
583
				p.parseError(fmt.Sprintf("invalid escape sequence '\\%c'", p.currentByte))
584
				return
585
			}
586
			escaped = false
587
		} else {
588
			switch p.currentByte {
589
			case '\n':
590
				return
591
			case '\\':
592
				escaped = true
593
			default:
594
				p.currentToken.WriteByte(p.currentByte)
595
			}
596
		}
597
		p.currentByte, p.err = p.buf.ReadByte()
598
	}
599
}
600

601
// readTokenAsMetricName copies a metric name from p.buf into p.currentToken.
602
// The first byte considered is the byte already read (now in p.currentByte).
603
// The first byte not part of a metric name is still copied into p.currentByte,
604
// but not into p.currentToken.
605
func (p *TextParser) readTokenAsMetricName() {
606
	p.currentToken.Reset()
607
	if !isValidMetricNameStart(p.currentByte) {
608
		return
609
	}
610
	for {
611
		p.currentToken.WriteByte(p.currentByte)
612
		p.currentByte, p.err = p.buf.ReadByte()
613
		if p.err != nil || !isValidMetricNameContinuation(p.currentByte) {
614
			return
615
		}
616
	}
617
}
618

619
// readTokenAsLabelName copies a label name from p.buf into p.currentToken.
620
// The first byte considered is the byte already read (now in p.currentByte).
621
// The first byte not part of a label name is still copied into p.currentByte,
622
// but not into p.currentToken.
623
func (p *TextParser) readTokenAsLabelName() {
624
	p.currentToken.Reset()
625
	if !isValidLabelNameStart(p.currentByte) {
626
		return
627
	}
628
	for {
629
		p.currentToken.WriteByte(p.currentByte)
630
		p.currentByte, p.err = p.buf.ReadByte()
631
		if p.err != nil || !isValidLabelNameContinuation(p.currentByte) {
632
			return
633
		}
634
	}
635
}
636

637
// readTokenAsLabelValue copies a label value from p.buf into p.currentToken.
638
// In contrast to the other 'readTokenAs...' functions, which start with the
639
// last read byte in p.currentByte, this method ignores p.currentByte and starts
640
// with reading a new byte from p.buf. The first byte not part of a label value
641
// is still copied into p.currentByte, but not into p.currentToken.
642
func (p *TextParser) readTokenAsLabelValue() {
643
	p.currentToken.Reset()
644
	escaped := false
645
	for {
646
		if p.currentByte, p.err = p.buf.ReadByte(); p.err != nil {
647
			return
648
		}
649
		if escaped {
650
			switch p.currentByte {
651
			case '"', '\\':
652
				p.currentToken.WriteByte(p.currentByte)
653
			case 'n':
654
				p.currentToken.WriteByte('\n')
655
			default:
656
				p.parseError(fmt.Sprintf("invalid escape sequence '\\%c'", p.currentByte))
657
				return
658
			}
659
			escaped = false
660
			continue
661
		}
662
		switch p.currentByte {
663
		case '"':
664
			return
665
		case '\n':
666
			p.parseError(fmt.Sprintf("label value %q contains unescaped new-line", p.currentToken.String()))
667
			return
668
		case '\\':
669
			escaped = true
670
		default:
671
			p.currentToken.WriteByte(p.currentByte)
672
		}
673
	}
674
}
675

676
func (p *TextParser) setOrCreateCurrentMF() {
677
	p.currentIsSummaryCount = false
678
	p.currentIsSummarySum = false
679
	p.currentIsHistogramCount = false
680
	p.currentIsHistogramSum = false
681
	name := p.currentToken.String()
682
	if p.currentMF = p.metricFamiliesByName[name]; p.currentMF != nil {
683
		return
684
	}
685
	// Try out if this is a _sum or _count for a summary/histogram.
686
	summaryName := summaryMetricName(name)
687
	if p.currentMF = p.metricFamiliesByName[summaryName]; p.currentMF != nil {
688
		if p.currentMF.GetType() == dto.MetricType_SUMMARY {
689
			if isCount(name) {
690
				p.currentIsSummaryCount = true
691
			}
692
			if isSum(name) {
693
				p.currentIsSummarySum = true
694
			}
695
			return
696
		}
697
	}
698
	histogramName := histogramMetricName(name)
699
	if p.currentMF = p.metricFamiliesByName[histogramName]; p.currentMF != nil {
700
		if p.currentMF.GetType() == dto.MetricType_HISTOGRAM {
701
			if isCount(name) {
702
				p.currentIsHistogramCount = true
703
			}
704
			if isSum(name) {
705
				p.currentIsHistogramSum = true
706
			}
707
			return
708
		}
709
	}
710
	p.currentMF = &dto.MetricFamily{Name: proto.String(name)}
711
	p.metricFamiliesByName[name] = p.currentMF
712
}
713

714
func isValidLabelNameStart(b byte) bool {
715
	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || b == '_'
716
}
717

718
func isValidLabelNameContinuation(b byte) bool {
719
	return isValidLabelNameStart(b) || (b >= '0' && b <= '9')
720
}
721

722
func isValidMetricNameStart(b byte) bool {
723
	return isValidLabelNameStart(b) || b == ':'
724
}
725

726
func isValidMetricNameContinuation(b byte) bool {
727
	return isValidLabelNameContinuation(b) || b == ':'
728
}
729

730
func isBlankOrTab(b byte) bool {
731
	return b == ' ' || b == '\t'
732
}
733

734
func isCount(name string) bool {
735
	return len(name) > 6 && name[len(name)-6:] == "_count"
736
}
737

738
func isSum(name string) bool {
739
	return len(name) > 4 && name[len(name)-4:] == "_sum"
740
}
741

742
func isBucket(name string) bool {
743
	return len(name) > 7 && name[len(name)-7:] == "_bucket"
744
}
745

746
func summaryMetricName(name string) string {
747
	switch {
748
	case isCount(name):
749
		return name[:len(name)-6]
750
	case isSum(name):
751
		return name[:len(name)-4]
752
	default:
753
		return name
754
	}
755
}
756

757
func histogramMetricName(name string) string {
758
	switch {
759
	case isCount(name):
760
		return name[:len(name)-6]
761
	case isSum(name):
762
		return name[:len(name)-4]
763
	case isBucket(name):
764
		return name[:len(name)-7]
765
	default:
766
		return name
767
	}
768
}
769

770
func parseFloat(s string) (float64, error) {
771
	if strings.ContainsAny(s, "pP_") {
772
		return 0, fmt.Errorf("unsupported character in float")
773
	}
774
	return strconv.ParseFloat(s, 64)
775
}
776