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 14package expfmt 15 16import ( 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" 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. 35type stateFn func() stateFn 36 37// ParseError signals errors while parsing the simple and flat text-based 38// exchange format. 39type ParseError struct { 40 Line int 41 Msg string 42} 43 44// Error implements the error interface. 45func (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. 51type 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. 100func (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 121func (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). 142func (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). 161func (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. 222func (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). 249func (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). 267func (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). 318func (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). 380func (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). 468func (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'. 494func (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'. 509func (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. 529func (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. 538func (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'. 548func (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. 558func (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. 572func (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. 605func (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. 623func (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. 642func (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 676func (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 714func isValidLabelNameStart(b byte) bool { 715 return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || b == '_' 716} 717 718func isValidLabelNameContinuation(b byte) bool { 719 return isValidLabelNameStart(b) || (b >= '0' && b <= '9') 720} 721 722func isValidMetricNameStart(b byte) bool { 723 return isValidLabelNameStart(b) || b == ':' 724} 725 726func isValidMetricNameContinuation(b byte) bool { 727 return isValidLabelNameContinuation(b) || b == ':' 728} 729 730func isBlankOrTab(b byte) bool { 731 return b == ' ' || b == '\t' 732} 733 734func isCount(name string) bool { 735 return len(name) > 6 && name[len(name)-6:] == "_count" 736} 737 738func isSum(name string) bool { 739 return len(name) > 4 && name[len(name)-4:] == "_sum" 740} 741 742func isBucket(name string) bool { 743 return len(name) > 7 && name[len(name)-7:] == "_bucket" 744} 745 746func 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 757func 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 770func 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