prometheus/pkg/textparse/parse.go

152 lines
3.4 KiB
Go
Raw Normal View History

// Copyright 2017 The Prometheus Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
2017-01-16 11:34:49 -08:00
//go:generate go get github.com/cznic/golex
2017-01-14 07:39:04 -08:00
//go:generate golex -o=lex.l.go lex.l
2017-01-16 11:34:49 -08:00
// Package textparse contains an efficient parser for the Prometheus text format.
2017-01-14 07:39:04 -08:00
package textparse
import (
"errors"
"io"
"sort"
"strings"
2017-01-14 07:39:04 -08:00
"unsafe"
"github.com/prometheus/prometheus/pkg/labels"
2017-01-14 07:39:04 -08:00
)
type lexer struct {
b []byte
i int
vstart int
tstart int
2017-01-14 07:39:04 -08:00
err error
val float64
ts *int64
offsets []int
mstart, mend int
nextMstart int
state int
2017-01-14 07:39:04 -08:00
}
const eof = 0
func (l *lexer) next() byte {
l.i++
if l.i >= len(l.b) {
l.err = io.EOF
return eof
}
c := l.b[l.i]
// Consume null byte when encountered in label-value.
if c == eof && (l.state == lstateLValueIn || l.state == lstateLValue) {
return l.next()
}
2017-01-14 07:39:04 -08:00
return c
}
func (l *lexer) Error(es string) {
l.err = errors.New(es)
}
2017-01-16 11:34:49 -08:00
// Parser parses samples from a byte slice of samples in the official
// Prometheus text exposition format.
2017-01-14 07:39:04 -08:00
type Parser struct {
l *lexer
err error
val float64
}
2017-01-16 11:34:49 -08:00
// New returns a new parser of the byte slice.
2017-01-14 07:39:04 -08:00
func New(b []byte) *Parser {
return &Parser{l: &lexer{b: b}}
}
2017-01-16 11:34:49 -08:00
// Next advances the parser to the next sample. It returns false if no
// more samples were read or an error occurred.
2017-01-14 07:39:04 -08:00
func (p *Parser) Next() bool {
switch p.l.Lex() {
case -1, eof:
2017-01-14 07:39:04 -08:00
return false
case 1:
return true
}
panic("unexpected")
}
2017-01-16 11:34:49 -08:00
// At returns the bytes of the metric, the timestamp if set, and the value
// of the current sample.
2017-01-14 07:39:04 -08:00
func (p *Parser) At() ([]byte, *int64, float64) {
return p.l.b[p.l.mstart:p.l.mend], p.l.ts, p.l.val
2017-01-14 07:39:04 -08:00
}
2017-01-16 11:34:49 -08:00
// Err returns the current error.
2017-01-14 07:39:04 -08:00
func (p *Parser) Err() error {
if p.err != nil {
return p.err
}
if p.l.err == io.EOF {
return nil
}
return p.l.err
}
2017-01-16 11:34:49 -08:00
// Metric writes the labels of the current sample into the passed labels.
2017-05-26 01:44:48 -07:00
// It returns the string from which the metric was parsed.
func (p *Parser) Metric(l *labels.Labels) string {
// Allocate the full immutable string immediately, so we just
// have to create references on it below.
s := string(p.l.b[p.l.mstart:p.l.mend])
*l = append(*l, labels.Label{
Name: labels.MetricName,
Value: s[:p.l.offsets[0]-p.l.mstart],
})
for i := 1; i < len(p.l.offsets); i += 4 {
a := p.l.offsets[i] - p.l.mstart
b := p.l.offsets[i+1] - p.l.mstart
c := p.l.offsets[i+2] - p.l.mstart
d := p.l.offsets[i+3] - p.l.mstart
// Replacer causes allocations. Replace only when necessary.
if strings.IndexByte(s[c:d], byte('\\')) >= 0 {
*l = append(*l, labels.Label{Name: s[a:b], Value: replacer.Replace(s[c:d])})
continue
}
*l = append(*l, labels.Label{Name: s[a:b], Value: s[c:d]})
}
sort.Sort((*l)[1:])
return s
2017-01-14 07:39:04 -08:00
}
var replacer = strings.NewReplacer(
`\"`, `"`,
`\\`, `\`,
`\n`, `
`,
`\t`, ` `,
)
2017-01-14 07:39:04 -08:00
func yoloString(b []byte) string {
return *((*string)(unsafe.Pointer(&b)))
2017-01-14 07:39:04 -08:00
}