From 9515413446affd23b422cd7c6159c8ddea3d83c6 Mon Sep 17 00:00:00 2001 From: Fabian Reinartz Date: Thu, 8 Nov 2018 04:53:41 -0500 Subject: [PATCH 1/4] Update to Prometheus 2.5.0 Signed-off-by: Fabian Reinartz --- kube/prometheus-meta-operated.yaml | 2 +- kube/prometheus-meta.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/kube/prometheus-meta-operated.yaml b/kube/prometheus-meta-operated.yaml index 3749e867..4b159986 100644 --- a/kube/prometheus-meta-operated.yaml +++ b/kube/prometheus-meta-operated.yaml @@ -15,7 +15,7 @@ spec: matchExpressions: - key: app operator: Exists - version: v2.4.3 + version: v2.5.0 # Inject the sidecar container. containers: - name: sidecar diff --git a/kube/prometheus-meta.yaml b/kube/prometheus-meta.yaml index 6673f621..32df1b24 100644 --- a/kube/prometheus-meta.yaml +++ b/kube/prometheus-meta.yaml @@ -22,7 +22,7 @@ spec: runAsUser: 0 containers: - name: prometheus - image: quay.io/prometheus/prometheus:v2.4.3 + image: quay.io/prometheus/prometheus:v2.5.0 imagePullPolicy: Always args: - "--config.file=/etc/prometheus/config/prometheus.yaml" From f0ab539e477371e65c58d258bd3dd823f96403a5 Mon Sep 17 00:00:00 2001 From: Fabian Reinartz Date: Thu, 8 Nov 2018 04:58:39 -0500 Subject: [PATCH 2/4] Update pkg/textparse to v2.5 Signed-off-by: Fabian Reinartz --- .../prometheus/pkg/textparse/cpu.out | Bin 0 -> 16257 bytes .../prometheus/pkg/textparse/cpu.svg | 2950 +++++++++++++++++ .../prometheus/pkg/textparse/interface.go | 91 + .../prometheus/pkg/textparse/openmetricslex.l | 71 + .../pkg/textparse/openmetricslex.l.go | 586 ++++ .../pkg/textparse/openmetricsparse.go | 347 ++ .../pkg/textparse/{lex.l => promlex.l} | 6 +- .../pkg/textparse/{lex.l.go => promlex.l.go} | 10 +- .../pkg/textparse/{parse.go => promparse.go} | 103 +- ...ata.nometa.txt => promtestdata.nometa.txt} | 1 + .../{testdata.txt => promtestdata.txt} | 3 +- .../prometheus/prometheus/scrape/manager.go | 151 +- .../prometheus/prometheus/scrape/scrape.go | 129 +- .../prometheus/prometheus/scrape/target.go | 21 +- vendor/vendor.json | 12 +- 15 files changed, 4307 insertions(+), 174 deletions(-) create mode 100644 vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.out create mode 100644 vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.svg create mode 100644 vendor/github.com/prometheus/prometheus/pkg/textparse/interface.go create mode 100644 vendor/github.com/prometheus/prometheus/pkg/textparse/openmetricslex.l create mode 100644 vendor/github.com/prometheus/prometheus/pkg/textparse/openmetricslex.l.go create mode 100644 vendor/github.com/prometheus/prometheus/pkg/textparse/openmetricsparse.go rename vendor/github.com/prometheus/prometheus/pkg/textparse/{lex.l => promlex.l} (95%) rename vendor/github.com/prometheus/prometheus/pkg/textparse/{lex.l.go => promlex.l.go} (98%) rename vendor/github.com/prometheus/prometheus/pkg/textparse/{parse.go => promparse.go} (81%) rename vendor/github.com/prometheus/prometheus/pkg/textparse/{testdata.nometa.txt => promtestdata.nometa.txt} (99%) rename vendor/github.com/prometheus/prometheus/pkg/textparse/{testdata.txt => promtestdata.txt} (99%) diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.out b/vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.out new file mode 100644 index 0000000000000000000000000000000000000000..30775204e49187ae9901b6b08efd7bc57b8f211c GIT binary patch literal 16257 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 literal 0 HcmV?d00001 diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.svg b/vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.svg new file mode 100644 index 00000000..3ec8aa70 --- /dev/null +++ b/vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.svg @@ -0,0 +1,2950 @@ + + + + + + +textparse.test + +cluster_L + + + +File: textparse.test + + +File: textparse.test +Type: cpu +Time: May 25, 2018 at 9:13am (EDT) +Duration: 18.57s, Total samples = 19.78s (106.52%) +Showing nodes accounting for 16.87s, 85.29% of 19.78s total +Dropped 201 nodes (cum <= 0.10s) +Dropped 27 edges (freq <= 0.02s) +Showing top 80 nodes out of 142 + + + + +N1 + + +testing +(*B) +runN +0 of 17.42s (88.07%) + + + + +N2 + + +github +com/prometheus/prometheus/pkg/textparse +(*Parser) +Next +0.33s (1.67%) +of 8.87s (44.84%) + + + + +N1->N2 + + + + + + + 3.61s + + + + +N10 + + +github +com/prometheus/prometheus/pkg/textparse +BenchmarkParse +func2 +0.02s (0.1%) +of 3.81s (19.26%) + + + + +N1->N10 + + + + + + + 3.81s + + + + +N14 + + +github +com/prometheus/prometheus/pkg/textparse +BenchmarkParse +func3 +0 of 3.91s (19.77%) + + + + +N1->N14 + + + + + + + 3.91s + + + + +N27 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/expfmt +(*SampleDecoder) +Decode +0.01s (0.051%) +of 3.17s (16.03%) + + + + +N1->N27 + + + + + + + 3.17s + + + + +N37 + + +github +com/prometheus/prometheus/pkg/textparse +BenchmarkGzip +func1 +0 of 2.90s (14.66%) + + + + +N1->N37 + + + + + + + 2.90s + + + + +N7 + + +github +com/prometheus/prometheus/pkg/textparse +(*Parser) +nextToken +0.27s (1.37%) +of 7.45s (37.66%) + + + + +N2->N7 + + + + + + + 5.04s + + + + +N15 + + +github +com/prometheus/prometheus/pkg/textparse +(*Parser) +parseLVals +0.26s (1.31%) +of 2.93s (14.81%) + + + + +N2->N15 + + + + + + + 2.93s + + + + +N41 + + +strconv +ParseFloat +0.07s (0.35%) +of 0.58s (2.93%) + + + + +N2->N41 + + + + + + + 0.49s + + + + +N55 + + +runtime +gcWriteBarrier +0.04s (0.2%) +of 0.11s (0.56%) + + + + +N2->N55 + + + + + + + 0.02s + + + + +N57 + + +runtime +growslice +0.02s (0.1%) +of 0.18s (0.91%) + + + + +N2->N57 + + + + + + + 0.02s + + + + +N3 + + +testing +(*B) +launch +0 of 17.41s (88.02%) + + + + +N3->N1 + + + + + + + 17.41s + + + + +N4 + + +runtime +mallocgc +0.91s (4.60%) +of 3.27s (16.53%) + + + + +N21 + + +runtime +memclrNoHeapPointers +0.73s (3.69%) + + + + +N4->N21 + + + + + + + 0.03s + + + + +N38 + + +runtime +heapBitsSetType +0.43s (2.17%) +of 0.46s (2.33%) + + + + +N4->N38 + + + + + + + 0.46s + + + + +N51 + + +runtime +nextFreeFast +0.28s (1.42%) + + + + +N4->N51 + + + + + + + 0.28s + (inline) + + + + +N79 + + +runtime +(*mcache) +nextFree +0.03s (0.15%) +of 0.98s (4.95%) + + + + +N4->N79 + + + + + + + 0.98s + + + + +N5 + + +github +com/prometheus/prometheus/pkg/textparse +(*lexer) +Lex +3.83s (19.36%) +of 7.18s (36.30%) + + + + +N11 + + +github +com/prometheus/prometheus/pkg/textparse +(*lexer) +next +2.75s (13.90%) +of 3.35s (16.94%) + + + + +N5->N11 + + + + + + + 3.35s + + + + +N6 + + +runtime +systemstack +0.03s (0.15%) +of 2.68s (13.55%) + + + + +N30 + + +runtime +gcDrain +0.08s (0.4%) +of 0.86s (4.35%) + + + + +N6->N30 + + + + + + + 0.84s + + + + +N44 + + +runtime +heapBitsForObject +0.20s (1.01%) + + + + +N6->N44 + + + + + + + 0.03s + + + + +N47 + + +runtime +notewakeup +0.02s (0.1%) +of 0.38s (1.92%) + + + + +N6->N47 + + + + + + + 0.21s + + + + +N50 + + +runtime +(*mcentral) +cacheSpan +0.01s (0.051%) +of 0.94s (4.75%) + + + + +N6->N50 + + + + + + + 0.94s + + + + +N73 + + +runtime +gcDrainN +0 of 0.24s (1.21%) + + + + +N6->N73 + + + + + + + 0.24s + + + + +N7->N5 + + + + + + + 7.18s + + + + +N8 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/expfmt +(*TextParser) +TextToMetricFamilies +0.01s (0.051%) +of 2.89s (14.61%) + + + + +N12 + + +runtime +newobject +0.06s (0.3%) +of 1.01s (5.11%) + + + + +N8->N12 + + + + + + + 0.12s + + + + +N23 + + +bufio +(*Reader) +ReadByte +0.40s (2.02%) + + + + +N8->N23 + + + + + + + 0.03s + + + + +N26 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/expfmt +(*TextParser) +startLabelName +0.03s (0.15%) +of 0.62s (3.13%) + + + + +N8->N26 + + + + + + + 0.62s + + + + +N29 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/expfmt +(*TextParser) +readingValue +0.04s (0.2%) +of 0.54s (2.73%) + + + + +N8->N29 + + + + + + + 0.54s + + + + +N35 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/expfmt +(*TextParser) +readingMetricName +0 of 0.80s (4.04%) + + + + +N8->N35 + + + + + + + 0.80s + + + + +N36 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/expfmt +(*TextParser) +startLabelValue +0.05s (0.25%) +of 0.41s (2.07%) + + + + +N8->N36 + + + + + + + 0.41s + + + + +N62 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/expfmt +(*TextParser) +startComment +0.01s (0.051%) +of 0.19s (0.96%) + + + + +N8->N62 + + + + + + + 0.19s + + + + +N9 + + +github +com/prometheus/prometheus/pkg/textparse +(*Parser) +Metric +0.26s (1.31%) +of 1.78s (9.00%) + + + + +N25 + + +runtime +slicebytetostring +0.05s (0.25%) +of 0.79s (3.99%) + + + + +N9->N25 + + + + + + + 0.60s + + + + +N9->N55 + + + + + + + 0.03s + + + + +N60 + + +runtime +convT2Islice +0.04s (0.2%) +of 0.53s (2.68%) + + + + +N9->N60 + + + + + + + 0.50s + + + + +N64 + + +sort +Sort +0.03s (0.15%) +of 0.26s (1.31%) + + + + +N9->N64 + + + + + + + 0.25s + + + + +N75 + + +runtime +indexbytebody +0.14s (0.71%) + + + + +N9->N75 + + + + + + + 0.14s + + + + +N10->N2 + + + + + + + 2.42s + + + + +N10->N9 + + + + + + + 0.71s + + + + +N10->N12 + + + + + + + 0.02s + + + + +N17 + + +runtime +makeslice +0.02s (0.1%) +of 1.09s (5.51%) + + + + +N10->N17 + + + + + + + 0.64s + + + + +N33 + + +github +com/prometheus/prometheus/pkg/textparse +(*lexer) +cur +0.60s (3.03%) + + + + +N11->N33 + + + + + + + 0.60s + (inline) + + + + +N12->N4 + + + + + + + 0.95s + + + + +N13 + + +compress/flate +(*decompressor) +huffmanBlock +0.44s (2.22%) +of 1.97s (9.96%) + + + + +N18 + + +compress/flate +(*decompressor) +moreBits +0.42s (2.12%) +of 0.80s (4.04%) + + + + +N13->N18 + + + + + + + 0.20s + + + + +N19 + + +compress/flate +(*decompressor) +huffSym +0.48s (2.43%) +of 1.08s (5.46%) + + + + +N13->N19 + + + + + + + 1.03s + + + + +N66 + + +compress/flate +(*dictDecoder) +tryWriteCopy +0.13s (0.66%) +of 0.22s (1.11%) + + + + +N13->N66 + + + + + + + 0.22s + (inline) + + + + +N14->N2 + + + + + + + 2.84s + + + + +N14->N9 + + + + + + + 1.07s + + + + +N15->N7 + + + + + + + 2.41s + + + + +N61 + + +unicode/utf8 +Valid +0.19s (0.96%) + + + + +N15->N61 + + + + + + + 0.19s + + + + +N16 + + +runtime +futex +0.79s (3.99%) + + + + +N17->N4 + + + + + + + 1.07s + + + + +N42 + + +bytes +(*Reader) +ReadByte +0.38s (1.92%) + + + + +N18->N42 + + + + + + + 0.38s + + + + +N19->N18 + + + + + + + 0.60s + + + + +N20 + + +bytes +(*Buffer) +ReadFrom +0 of 2.63s (13.30%) + + + + +N20->N17 + + + + + + + 0.31s + + + + +N32 + + +runtime +memmove +0.31s (1.57%) + + + + +N20->N32 + + + + + + + 0.03s + + + + +N77 + + +compress/flate +(*decompressor) +Read +0 of 2.16s (10.92%) + + + + +N20->N77 + + + + + + + 2.16s + + + + +N22 + + +runtime +schedule +0.01s (0.051%) +of 0.71s (3.59%) + + + + +N22->N55 + + + + + + + 0.02s + + + + +N68 + + +runtime +findrunnable +0.02s (0.1%) +of 0.41s (2.07%) + + + + +N22->N68 + + + + + + + 0.41s + + + + +N24 + + +runtime +scanobject +0.31s (1.57%) +of 0.62s (3.13%) + + + + +N24->N44 + + + + + + + 0.13s + + + + +N70 + + +runtime +greyobject +0.08s (0.4%) +of 0.12s (0.61%) + + + + +N24->N70 + + + + + + + 0.08s + + + + +N25->N4 + + + + + + + 0.60s + + + + +N25->N32 + + + + + + + 0.14s + + + + +N26->N12 + + + + + + + 0.18s + + + + +N26->N57 + + + + + + + 0.11s + + + + +N59 + + +bytes +(*Buffer) +String +0.01s (0.051%) +of 0.19s (0.96%) + + + + +N26->N59 + + + + + + + 0.08s + (inline) + + + + +N69 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/expfmt +(*TextParser) +readTokenAsLabelName +0.06s (0.3%) +of 0.18s (0.91%) + + + + +N26->N69 + + + + + + + 0.18s + + + + +N27->N8 + + + + + + + 2.89s + + + + +N56 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/expfmt +extractUntyped +0.03s (0.15%) +of 0.27s (1.37%) + + + + +N27->N56 + + + + + + + 0.27s + + + + +N28 + + +runtime +gcBgMarkWorker +0.03s (0.15%) +of 1.20s (6.07%) + + + + +N28->N6 + + + + + + + 1.14s + + + + +N29->N12 + + + + + + + 0.08s + + + + +N29->N41 + + + + + + + 0.08s + + + + +N29->N57 + + + + + + + 0.04s + + + + +N67 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/model +LabelsToSignature +0 of 0.15s (0.76%) + + + + +N29->N67 + + + + + + + 0.15s + + + + +N78 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/expfmt +(*TextParser) +readTokenUntilWhitespace +0.06s (0.3%) +of 0.10s (0.51%) + + + + +N29->N78 + + + + + + + 0.09s + + + + +N30->N24 + + + + + + + 0.53s + + + + +N74 + + +runtime +markroot +0 of 0.29s (1.47%) + + + + +N30->N74 + + + + + + + 0.17s + + + + +N31 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/expfmt +(*TextParser) +readTokenAsMetricName +0.10s (0.51%) +of 0.54s (2.73%) + + + + +N31->N23 + + + + + + + 0.22s + + + + +N43 + + +bytes +(*Buffer) +WriteByte +0.15s (0.76%) +of 0.21s (1.06%) + + + + +N31->N43 + + + + + + + 0.13s + + + + +N34 + + +runtime +stopm +0 of 0.45s (2.28%) + + + + +N34->N30 + + + + + + + 0.02s + + + + +N34->N47 + + + + + + + 0.02s + + + + +N52 + + +runtime +lock +0.07s (0.35%) +of 0.19s (0.96%) + + + + +N34->N52 + + + + + + + 0.11s + + + + +N53 + + +runtime +futexsleep +0.01s (0.051%) +of 0.34s (1.72%) + + + + +N34->N53 + + + + + + + 0.20s + + + + +N58 + + +runtime +unlock +0.04s (0.2%) +of 0.14s (0.71%) + + + + +N34->N58 + + + + + + + 0.08s + + + + +N35->N12 + + + + + + + 0.13s + + + + +N35->N31 + + + + + + + 0.46s + + + + +N40 + + +github +com/prometheus/prometheus/vendor/github +com/prometheus/common/expfmt +(*TextParser) +setOrCreateCurrentMF +0.04s (0.2%) +of 0.28s (1.42%) + + + + +N35->N40 + + + + + + + 0.21s + + + + +N36->N12 + + + + + + + 0.12s + + + + +N36->N23 + + + + + + + 0.05s + + + + +N36->N43 + + + + + + + 0.03s + + + + +N36->N59 + + + + + + + 0.06s + (inline) + + + + +N37->N12 + + + + + + + 0.06s + + + + +N37->N17 + + + + + + + 0.07s + + + + +N54 + + +io/ioutil +readAll +0.01s (0.051%) +of 2.72s (13.75%) + + + + +N37->N54 + + + + + + + 2.72s + + + + +N39 + + +runtime +mcall +0 of 0.63s (3.19%) + + + + +N39->N22 + + + + + + + 0.57s + + + + +N80 + + +runtime +goschedImpl +0 of 0.19s (0.96%) + + + + +N39->N80 + + + + + + + 0.05s + + + + +N40->N12 + + + + + + + 0.02s + + + + +N46 + + +runtime +mapassign_faststr +0.05s (0.25%) +of 0.23s (1.16%) + + + + +N40->N46 + + + + + + + 0.06s + + + + +N40->N59 + + + + + + + 0.03s + (inline) + + + + +N76 + + +runtime +mapaccess1_faststr +0.09s (0.46%) +of 0.12s (0.61%) + + + + +N40->N76 + + + + + + + 0.11s + + + + +N48 + + +strconv +atof64 +0.12s (0.61%) +of 0.51s (2.58%) + + + + +N41->N48 + + + + + + + 0.51s + + + + +N45 + + +runtime +(*mheap) +alloc +0.01s (0.051%) +of 0.83s (4.20%) + + + + +N45->N21 + + + + + + + 0.69s + + + + +N71 + + +runtime +sweepone +0.10s (0.51%) +of 0.20s (1.01%) + + + + +N45->N71 + + + + + + + 0.03s + + + + +N46->N12 + + + + + + + 0.12s + + + + +N65 + + +runtime +futexwakeup +0 of 0.46s (2.33%) + + + + +N47->N65 + + + + + + + 0.36s + + + + +N63 + + +strconv +readFloat +0.18s (0.91%) + + + + +N48->N63 + + + + + + + 0.18s + + + + +N49 + + +compress/flate +(*decompressor) +nextBlock +0 of 2.13s (10.77%) + + + + +N49->N13 + + + + + + + 1.96s + + + + +N49->N17 + + + + + + + 0.03s + + + + +N50->N45 + + + + + + + 0.77s + + + + +N50->N52 + + + + + + + 0.04s + + + + +N50->N58 + + + + + + + 0.02s + + + + +N52->N53 + + + + + + + 0.08s + + + + +N53->N16 + + + + + + + 0.33s + + + + +N54->N12 + + + + + + + 0.06s + + + + +N54->N20 + + + + + + + 2.63s + + + + +N55->N6 + + + + + + + 0.03s + + + + +N55->N44 + + + + + + + 0.02s + + + + +N56->N12 + + + + + + + 0.06s + + + + +N56->N17 + + + + + + + 0.02s + + + + +N56->N46 + + + + + + + 0.12s + + + + +N57->N4 + + + + + + + 0.15s + + + + +N58->N65 + + + + + + + 0.10s + + + + +N59->N25 + + + + + + + 0.18s + + + + +N60->N4 + + + + + + + 0.49s + + + + +N62->N12 + + + + + + + 0.02s + + + + +N62->N31 + + + + + + + 0.08s + + + + +N62->N40 + + + + + + + 0.07s + + + + +N65->N16 + + + + + + + 0.46s + + + + +N66->N32 + + + + + + + 0.09s + + + + +N67->N17 + + + + + + + 0.02s + + + + +N67->N60 + + + + + + + 0.03s + + + + +N68->N34 + + + + + + + 0.35s + + + + +N69->N23 + + + + + + + 0.07s + + + + +N69->N43 + + + + + + + 0.02s + + + + +N72 + + +runtime +scanblock +0.09s (0.46%) +of 0.15s (0.76%) + + + + +N72->N44 + + + + + + + 0.02s + + + + +N72->N70 + + + + + + + 0.04s + + + + +N73->N24 + + + + + + + 0.09s + + + + +N73->N74 + + + + + + + 0.12s + + + + +N74->N72 + + + + + + + 0.15s + + + + +N77->N32 + + + + + + + 0.02s + + + + +N77->N49 + + + + + + + 2.13s + + + + +N78->N23 + + + + + + + 0.02s + + + + +N78->N43 + + + + + + + 0.02s + + + + +N79->N6 + + + + + + + 0.94s + + + + +N80->N22 + + + + + + + 0.14s + + + + +N80->N52 + + + + + + + 0.03s + + + + + diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/interface.go b/vendor/github.com/prometheus/prometheus/pkg/textparse/interface.go new file mode 100644 index 00000000..330dffa8 --- /dev/null +++ b/vendor/github.com/prometheus/prometheus/pkg/textparse/interface.go @@ -0,0 +1,91 @@ +// Copyright 2018 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. + +package textparse + +import ( + "mime" + + "github.com/prometheus/prometheus/pkg/labels" +) + +// Parser parses samples from a byte slice of samples in the official +// Prometheus and OpenMetrics text exposition formats. +type Parser interface { + // Series returns the bytes of the series, the timestamp if set, and the value + // of the current sample. + Series() ([]byte, *int64, float64) + + // Help returns the metric name and help text in the current entry. + // Must only be called after Next returned a help entry. + // The returned byte slices become invalid after the next call to Next. + Help() ([]byte, []byte) + + // Type returns the metric name and type in the current entry. + // Must only be called after Next returned a type entry. + // The returned byte slices become invalid after the next call to Next. + Type() ([]byte, MetricType) + + // Unit returns the metric name and unit in the current entry. + // Must only be called after Next returned a unit entry. + // The returned byte slices become invalid after the next call to Next. + Unit() ([]byte, []byte) + + // Comment returns the text of the current comment. + // Must only be called after Next returned a comment entry. + // The returned byte slice becomes invalid after the next call to Next. + Comment() []byte + + // Metric writes the labels of the current sample into the passed labels. + // It returns the string from which the metric was parsed. + Metric(l *labels.Labels) string + + // Next advances the parser to the next sample. It returns false if no + // more samples were read or an error occurred. + Next() (Entry, error) +} + +// New returns a new parser of the byte slice. +func New(b []byte, contentType string) Parser { + mediaType, _, err := mime.ParseMediaType(contentType) + if err == nil && mediaType == "application/openmetrics-text" { + return NewOpenMetricsParser(b) + } + return NewPromParser(b) +} + +// Entry represents the type of a parsed entry. +type Entry int + +const ( + EntryInvalid Entry = -1 + EntryType Entry = 0 + EntryHelp Entry = 1 + EntrySeries Entry = 2 + EntryComment Entry = 3 + EntryUnit Entry = 4 +) + +// MetricType represents metric type values. +type MetricType string + +const ( + MetricTypeCounter = "counter" + MetricTypeGauge = "gauge" + MetricTypeHistogram = "histogram" + MetricTypeGaugeHistogram = "gaugehistogram" + MetricTypeSummary = "summary" + MetricTypeInfo = "info" + MetricTypeStateset = "stateset" + MetricTypeUnknown = "unknown" +) diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/openmetricslex.l b/vendor/github.com/prometheus/prometheus/pkg/textparse/openmetricslex.l new file mode 100644 index 00000000..a259885f --- /dev/null +++ b/vendor/github.com/prometheus/prometheus/pkg/textparse/openmetricslex.l @@ -0,0 +1,71 @@ +%{ +// Copyright 2018 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. + +package textparse + +import ( + "fmt" +) + +// Lex is called by the parser generated by "go tool yacc" to obtain each +// token. The method is opened before the matching rules block and closed at +// the end of the file. +func (l *openMetricsLexer) Lex() token { + if l.i >= len(l.b) { + return tEOF + } + c := l.b[l.i] + l.start = l.i + +%} + +D [0-9] +L [a-zA-Z_] +M [a-zA-Z_:] +C [^\n] +S [ ] + +%x sComment sMeta1 sMeta2 sLabels sLValue sValue sTimestamp + +%yyc c +%yyn c = l.next() +%yyt l.state + + +%% + +#{S} l.state = sComment +HELP{S} l.state = sMeta1; return tHelp +TYPE{S} l.state = sMeta1; return tType +UNIT{S} l.state = sMeta1; return tUnit +"EOF"\n? l.state = sInit; return tEofWord +{M}({M}|{D})* l.state = sMeta2; return tMName +{S}{C}*\n l.state = sInit; return tText + +{M}({M}|{D})* l.state = sValue; return tMName +\{ l.state = sLabels; return tBraceOpen +{L}({L}|{D})* return tLName +\} l.state = sValue; return tBraceClose += l.state = sLValue; return tEqual +, return tComma +\"(\\.|[^\\"\n])*\" l.state = sLabels; return tLValue +{S}[^ \n]+ l.state = sTimestamp; return tValue +{S}[^ \n]+ return tTimestamp +{S}#{S}{C}*\n l.state = sInit; return tLinebreak +\n l.state = sInit; return tLinebreak + +%% + + return tInvalid +} diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/openmetricslex.l.go b/vendor/github.com/prometheus/prometheus/pkg/textparse/openmetricslex.l.go new file mode 100644 index 00000000..4dd7ddd7 --- /dev/null +++ b/vendor/github.com/prometheus/prometheus/pkg/textparse/openmetricslex.l.go @@ -0,0 +1,586 @@ +// CAUTION: Generated file - DO NOT EDIT. + +// Copyright 2018 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. + +package textparse + +import ( + "fmt" +) + +// Lex is called by the parser generated by "go tool yacc" to obtain each +// token. The method is opened before the matching rules block and closed at +// the end of the file. +func (l *openMetricsLexer) Lex() token { + if l.i >= len(l.b) { + return tEOF + } + c := l.b[l.i] + l.start = l.i + +yystate0: + + switch yyt := l.state; yyt { + default: + panic(fmt.Errorf(`invalid start condition %d`, yyt)) + case 0: // start condition: INITIAL + goto yystart1 + case 1: // start condition: sComment + goto yystart5 + case 2: // start condition: sMeta1 + goto yystart25 + case 3: // start condition: sMeta2 + goto yystart27 + case 4: // start condition: sLabels + goto yystart30 + case 5: // start condition: sLValue + goto yystart35 + case 6: // start condition: sValue + goto yystart39 + case 7: // start condition: sTimestamp + goto yystart43 + } + + goto yystate0 // silence unused label error + goto yystate1 // silence unused label error +yystate1: + c = l.next() +yystart1: + switch { + default: + goto yyabort + case c == '#': + goto yystate2 + case c == ':' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate4 + } + +yystate2: + c = l.next() + switch { + default: + goto yyabort + case c == ' ': + goto yystate3 + } + +yystate3: + c = l.next() + goto yyrule1 + +yystate4: + c = l.next() + switch { + default: + goto yyrule8 + case c >= '0' && c <= ':' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate4 + } + + goto yystate5 // silence unused label error +yystate5: + c = l.next() +yystart5: + switch { + default: + goto yyabort + case c == 'E': + goto yystate6 + case c == 'H': + goto yystate10 + case c == 'T': + goto yystate15 + case c == 'U': + goto yystate20 + } + +yystate6: + c = l.next() + switch { + default: + goto yyabort + case c == 'O': + goto yystate7 + } + +yystate7: + c = l.next() + switch { + default: + goto yyabort + case c == 'F': + goto yystate8 + } + +yystate8: + c = l.next() + switch { + default: + goto yyrule5 + case c == '\n': + goto yystate9 + } + +yystate9: + c = l.next() + goto yyrule5 + +yystate10: + c = l.next() + switch { + default: + goto yyabort + case c == 'E': + goto yystate11 + } + +yystate11: + c = l.next() + switch { + default: + goto yyabort + case c == 'L': + goto yystate12 + } + +yystate12: + c = l.next() + switch { + default: + goto yyabort + case c == 'P': + goto yystate13 + } + +yystate13: + c = l.next() + switch { + default: + goto yyabort + case c == ' ': + goto yystate14 + } + +yystate14: + c = l.next() + goto yyrule2 + +yystate15: + c = l.next() + switch { + default: + goto yyabort + case c == 'Y': + goto yystate16 + } + +yystate16: + c = l.next() + switch { + default: + goto yyabort + case c == 'P': + goto yystate17 + } + +yystate17: + c = l.next() + switch { + default: + goto yyabort + case c == 'E': + goto yystate18 + } + +yystate18: + c = l.next() + switch { + default: + goto yyabort + case c == ' ': + goto yystate19 + } + +yystate19: + c = l.next() + goto yyrule3 + +yystate20: + c = l.next() + switch { + default: + goto yyabort + case c == 'N': + goto yystate21 + } + +yystate21: + c = l.next() + switch { + default: + goto yyabort + case c == 'I': + goto yystate22 + } + +yystate22: + c = l.next() + switch { + default: + goto yyabort + case c == 'T': + goto yystate23 + } + +yystate23: + c = l.next() + switch { + default: + goto yyabort + case c == ' ': + goto yystate24 + } + +yystate24: + c = l.next() + goto yyrule4 + + goto yystate25 // silence unused label error +yystate25: + c = l.next() +yystart25: + switch { + default: + goto yyabort + case c == ':' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate26 + } + +yystate26: + c = l.next() + switch { + default: + goto yyrule6 + case c >= '0' && c <= ':' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate26 + } + + goto yystate27 // silence unused label error +yystate27: + c = l.next() +yystart27: + switch { + default: + goto yyabort + case c == ' ': + goto yystate28 + } + +yystate28: + c = l.next() + switch { + default: + goto yyabort + case c == '\n': + goto yystate29 + case c >= '\x01' && c <= '\t' || c >= '\v' && c <= 'ÿ': + goto yystate28 + } + +yystate29: + c = l.next() + goto yyrule7 + + goto yystate30 // silence unused label error +yystate30: + c = l.next() +yystart30: + switch { + default: + goto yyabort + case c == ',': + goto yystate31 + case c == '=': + goto yystate32 + case c == '}': + goto yystate34 + case c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate33 + } + +yystate31: + c = l.next() + goto yyrule13 + +yystate32: + c = l.next() + goto yyrule12 + +yystate33: + c = l.next() + switch { + default: + goto yyrule10 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate33 + } + +yystate34: + c = l.next() + goto yyrule11 + + goto yystate35 // silence unused label error +yystate35: + c = l.next() +yystart35: + switch { + default: + goto yyabort + case c == '"': + goto yystate36 + } + +yystate36: + c = l.next() + switch { + default: + goto yyabort + case c == '"': + goto yystate37 + case c == '\\': + goto yystate38 + case c >= '\x01' && c <= '\t' || c >= '\v' && c <= '!' || c >= '#' && c <= '[' || c >= ']' && c <= 'ÿ': + goto yystate36 + } + +yystate37: + c = l.next() + goto yyrule14 + +yystate38: + c = l.next() + switch { + default: + goto yyabort + case c >= '\x01' && c <= '\t' || c >= '\v' && c <= 'ÿ': + goto yystate36 + } + + goto yystate39 // silence unused label error +yystate39: + c = l.next() +yystart39: + switch { + default: + goto yyabort + case c == ' ': + goto yystate40 + case c == '{': + goto yystate42 + } + +yystate40: + c = l.next() + switch { + default: + goto yyabort + case c >= '\x01' && c <= '\t' || c >= '\v' && c <= '\x1f' || c >= '!' && c <= 'ÿ': + goto yystate41 + } + +yystate41: + c = l.next() + switch { + default: + goto yyrule15 + case c >= '\x01' && c <= '\t' || c >= '\v' && c <= '\x1f' || c >= '!' && c <= 'ÿ': + goto yystate41 + } + +yystate42: + c = l.next() + goto yyrule9 + + goto yystate43 // silence unused label error +yystate43: + c = l.next() +yystart43: + switch { + default: + goto yyabort + case c == ' ': + goto yystate45 + case c == '\n': + goto yystate44 + } + +yystate44: + c = l.next() + goto yyrule18 + +yystate45: + c = l.next() + switch { + default: + goto yyabort + case c == '#': + goto yystate47 + case c >= '\x01' && c <= '\t' || c >= '\v' && c <= '\x1f' || c == '!' || c == '"' || c >= '$' && c <= 'ÿ': + goto yystate46 + } + +yystate46: + c = l.next() + switch { + default: + goto yyrule16 + case c >= '\x01' && c <= '\t' || c >= '\v' && c <= '\x1f' || c >= '!' && c <= 'ÿ': + goto yystate46 + } + +yystate47: + c = l.next() + switch { + default: + goto yyrule16 + case c == ' ': + goto yystate48 + case c >= '\x01' && c <= '\t' || c >= '\v' && c <= '\x1f' || c >= '!' && c <= 'ÿ': + goto yystate46 + } + +yystate48: + c = l.next() + switch { + default: + goto yyabort + case c == '\n': + goto yystate49 + case c >= '\x01' && c <= '\t' || c >= '\v' && c <= 'ÿ': + goto yystate48 + } + +yystate49: + c = l.next() + goto yyrule17 + +yyrule1: // #{S} + { + l.state = sComment + goto yystate0 + } +yyrule2: // HELP{S} + { + l.state = sMeta1 + return tHelp + goto yystate0 + } +yyrule3: // TYPE{S} + { + l.state = sMeta1 + return tType + goto yystate0 + } +yyrule4: // UNIT{S} + { + l.state = sMeta1 + return tUnit + goto yystate0 + } +yyrule5: // "EOF"\n? + { + l.state = sInit + return tEofWord + goto yystate0 + } +yyrule6: // {M}({M}|{D})* + { + l.state = sMeta2 + return tMName + goto yystate0 + } +yyrule7: // {S}{C}*\n + { + l.state = sInit + return tText + goto yystate0 + } +yyrule8: // {M}({M}|{D})* + { + l.state = sValue + return tMName + goto yystate0 + } +yyrule9: // \{ + { + l.state = sLabels + return tBraceOpen + goto yystate0 + } +yyrule10: // {L}({L}|{D})* + { + return tLName + } +yyrule11: // \} + { + l.state = sValue + return tBraceClose + goto yystate0 + } +yyrule12: // = + { + l.state = sLValue + return tEqual + goto yystate0 + } +yyrule13: // , + { + return tComma + } +yyrule14: // \"(\\.|[^\\"\n])*\" + { + l.state = sLabels + return tLValue + goto yystate0 + } +yyrule15: // {S}[^ \n]+ + { + l.state = sTimestamp + return tValue + goto yystate0 + } +yyrule16: // {S}[^ \n]+ + { + return tTimestamp + } +yyrule17: // {S}#{S}{C}*\n + { + l.state = sInit + return tLinebreak + goto yystate0 + } +yyrule18: // \n + { + l.state = sInit + return tLinebreak + goto yystate0 + } + panic("unreachable") + + goto yyabort // silence unused label error + +yyabort: // no lexem recognized + + return tInvalid +} diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/openmetricsparse.go b/vendor/github.com/prometheus/prometheus/pkg/textparse/openmetricsparse.go new file mode 100644 index 00000000..2d7b9215 --- /dev/null +++ b/vendor/github.com/prometheus/prometheus/pkg/textparse/openmetricsparse.go @@ -0,0 +1,347 @@ +// Copyright 2018 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. + +//go:generate go get github.com/cznic/golex +//go:generate golex -o=openmetricslex.l.go openmetricslex.l + +package textparse + +import ( + "errors" + "fmt" + "io" + "math" + "sort" + "strconv" + "strings" + "unicode/utf8" + + "github.com/prometheus/prometheus/pkg/labels" + "github.com/prometheus/prometheus/pkg/value" +) + +type openMetricsLexer struct { + b []byte + i int + start int + err error + state int +} + +// buf returns the buffer of the current token. +func (l *openMetricsLexer) buf() []byte { + return l.b[l.start:l.i] +} + +func (l *openMetricsLexer) cur() byte { + return l.b[l.i] +} + +// next advances the openMetricsLexer to the next character. +func (l *openMetricsLexer) next() byte { + l.i++ + if l.i >= len(l.b) { + l.err = io.EOF + return byte(tEOF) + } + // Lex struggles with null bytes. If we are in a label value or help string, where + // they are allowed, consume them here immediately. + for l.b[l.i] == 0 && (l.state == sLValue || l.state == sMeta2 || l.state == sComment) { + l.i++ + if l.i >= len(l.b) { + l.err = io.EOF + return byte(tEOF) + } + } + return l.b[l.i] +} + +func (l *openMetricsLexer) Error(es string) { + l.err = errors.New(es) +} + +// OpenMetricsParser parses samples from a byte slice of samples in the official +// OpenMetrics text exposition format. +// This is based on the working draft https://docs.google.com/document/u/1/d/1KwV0mAXwwbvvifBvDKH_LU1YjyXE_wxCkHNoCGq1GX0/edit +type OpenMetricsParser struct { + l *openMetricsLexer + series []byte + text []byte + mtype MetricType + val float64 + ts int64 + hasTS bool + start int + offsets []int +} + +// New returns a new parser of the byte slice. +func NewOpenMetricsParser(b []byte) Parser { + return &OpenMetricsParser{l: &openMetricsLexer{b: b}} +} + +// Series returns the bytes of the series, the timestamp if set, and the value +// of the current sample. +func (p *OpenMetricsParser) Series() ([]byte, *int64, float64) { + if p.hasTS { + return p.series, &p.ts, p.val + } + return p.series, nil, p.val +} + +// Help returns the metric name and help text in the current entry. +// Must only be called after Next returned a help entry. +// The returned byte slices become invalid after the next call to Next. +func (p *OpenMetricsParser) Help() ([]byte, []byte) { + m := p.l.b[p.offsets[0]:p.offsets[1]] + + // Replacer causes allocations. Replace only when necessary. + if strings.IndexByte(yoloString(p.text), byte('\\')) >= 0 { + // OpenMetrics always uses the Prometheus format label value escaping. + return m, []byte(lvalReplacer.Replace(string(p.text))) + } + return m, p.text +} + +// Type returns the metric name and type in the current entry. +// Must only be called after Next returned a type entry. +// The returned byte slices become invalid after the next call to Next. +func (p *OpenMetricsParser) Type() ([]byte, MetricType) { + return p.l.b[p.offsets[0]:p.offsets[1]], p.mtype +} + +// Unit returns the metric name and unit in the current entry. +// Must only be called after Next returned a unit entry. +// The returned byte slices become invalid after the next call to Next. +func (p *OpenMetricsParser) Unit() ([]byte, []byte) { + // The Prometheus format does not have units. + return p.l.b[p.offsets[0]:p.offsets[1]], p.text +} + +// Comment returns the text of the current comment. +// Must only be called after Next returned a comment entry. +// The returned byte slice becomes invalid after the next call to Next. +func (p *OpenMetricsParser) Comment() []byte { + return p.text +} + +// Metric writes the labels of the current sample into the passed labels. +// It returns the string from which the metric was parsed. +func (p *OpenMetricsParser) Metric(l *labels.Labels) string { + // Allocate the full immutable string immediately, so we just + // have to create references on it below. + s := string(p.series) + + *l = append(*l, labels.Label{ + Name: labels.MetricName, + Value: s[:p.offsets[0]-p.start], + }) + + for i := 1; i < len(p.offsets); i += 4 { + a := p.offsets[i] - p.start + b := p.offsets[i+1] - p.start + c := p.offsets[i+2] - p.start + d := p.offsets[i+3] - p.start + + // 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: lvalReplacer.Replace(s[c:d])}) + continue + } + *l = append(*l, labels.Label{Name: s[a:b], Value: s[c:d]}) + } + + // Sort labels. We can skip the first entry since the metric name is + // already at the right place. + sort.Sort((*l)[1:]) + + return s +} + +// nextToken returns the next token from the openMetricsLexer. +func (p *OpenMetricsParser) nextToken() token { + tok := p.l.Lex() + return tok +} + +// Next advances the parser to the next sample. It returns false if no +// more samples were read or an error occurred. +func (p *OpenMetricsParser) Next() (Entry, error) { + var err error + + p.start = p.l.i + p.offsets = p.offsets[:0] + + switch t := p.nextToken(); t { + case tEofWord: + if t := p.nextToken(); t != tEOF { + return EntryInvalid, fmt.Errorf("unexpected data after # EOF") + } + return EntryInvalid, io.EOF + case tEOF: + return EntryInvalid, parseError("unexpected end of data", t) + case tHelp, tType, tUnit: + switch t := p.nextToken(); t { + case tMName: + p.offsets = append(p.offsets, p.l.start, p.l.i) + default: + return EntryInvalid, parseError("expected metric name after HELP", t) + } + switch t := p.nextToken(); t { + case tText: + if len(p.l.buf()) > 1 { + p.text = p.l.buf()[1 : len(p.l.buf())-1] + } else { + p.text = []byte{} + } + default: + return EntryInvalid, parseError("expected text in HELP", t) + } + switch t { + case tType: + switch s := yoloString(p.text); s { + case "counter": + p.mtype = MetricTypeCounter + case "gauge": + p.mtype = MetricTypeGauge + case "histogram": + p.mtype = MetricTypeHistogram + case "gaugehistogram": + p.mtype = MetricTypeGaugeHistogram + case "summary": + p.mtype = MetricTypeSummary + case "info": + p.mtype = MetricTypeInfo + case "stateset": + p.mtype = MetricTypeStateset + case "unknown": + p.mtype = MetricTypeUnknown + default: + return EntryInvalid, fmt.Errorf("invalid metric type %q", s) + } + case tHelp: + if !utf8.Valid(p.text) { + return EntryInvalid, fmt.Errorf("help text is not a valid utf8 string") + } + } + switch t { + case tHelp: + return EntryHelp, nil + case tType: + return EntryType, nil + case tUnit: + m := yoloString(p.l.b[p.offsets[0]:p.offsets[1]]) + u := yoloString(p.text) + if len(u) > 0 { + if !strings.HasSuffix(m, u) || len(m) < len(u)+1 || p.l.b[p.offsets[1]-len(u)-1] != '_' { + return EntryInvalid, fmt.Errorf("unit not a suffix of metric %q", m) + } + } + return EntryUnit, nil + } + + case tMName: + p.offsets = append(p.offsets, p.l.i) + p.series = p.l.b[p.start:p.l.i] + + t2 := p.nextToken() + if t2 == tBraceOpen { + if err := p.parseLVals(); err != nil { + return EntryInvalid, err + } + p.series = p.l.b[p.start:p.l.i] + t2 = p.nextToken() + } + if t2 != tValue { + return EntryInvalid, parseError("expected value after metric", t) + } + if p.val, err = strconv.ParseFloat(yoloString(p.l.buf()[1:]), 64); err != nil { + return EntryInvalid, err + } + // Ensure canonical NaN value. + if math.IsNaN(p.val) { + p.val = math.Float64frombits(value.NormalNaN) + } + p.hasTS = false + switch p.nextToken() { + case tLinebreak: + break + case tTimestamp: + p.hasTS = true + var ts float64 + // A float is enough to hold what we need for millisecond resolution. + if ts, err = strconv.ParseFloat(yoloString(p.l.buf()[1:]), 64); err != nil { + return EntryInvalid, err + } + p.ts = int64(ts * 1000) + if t2 := p.nextToken(); t2 != tLinebreak { + return EntryInvalid, parseError("expected next entry after timestamp", t) + } + default: + return EntryInvalid, parseError("expected timestamp or new record", t) + } + return EntrySeries, nil + + default: + err = fmt.Errorf("%q %q is not a valid start token", t, string(p.l.cur())) + } + return EntryInvalid, err +} + +func (p *OpenMetricsParser) parseLVals() error { + first := true + for { + t := p.nextToken() + switch t { + case tBraceClose: + return nil + case tComma: + if first { + return parseError("expected label name or left brace", t) + } + t = p.nextToken() + if t != tLName { + return parseError("expected label name", t) + } + case tLName: + if !first { + return parseError("expected comma", t) + } + default: + if first { + return parseError("expected label name or left brace", t) + } + return parseError("expected comma or left brace", t) + + } + first = false + // t is now a label name. + + p.offsets = append(p.offsets, p.l.start, p.l.i) + + if t := p.nextToken(); t != tEqual { + return parseError("expected equal", t) + } + if t := p.nextToken(); t != tLValue { + return parseError("expected label value", t) + } + if !utf8.Valid(p.l.buf()) { + return fmt.Errorf("invalid UTF-8 label value") + } + + // The openMetricsLexer ensures the value string is quoted. Strip first + // and last character. + p.offsets = append(p.offsets, p.l.start+1, p.l.i-1) + + } +} diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/lex.l b/vendor/github.com/prometheus/prometheus/pkg/textparse/promlex.l similarity index 95% rename from vendor/github.com/prometheus/prometheus/pkg/textparse/lex.l rename to vendor/github.com/prometheus/prometheus/pkg/textparse/promlex.l index a6b728c7..c3c5c3bb 100644 --- a/vendor/github.com/prometheus/prometheus/pkg/textparse/lex.l +++ b/vendor/github.com/prometheus/prometheus/pkg/textparse/promlex.l @@ -32,7 +32,7 @@ const ( // Lex is called by the parser generated by "go tool yacc" to obtain each // token. The method is opened before the matching rules block and closed at // the end of the file. -func (l *lexer) Lex() token { +func (l *promlexer) Lex() token { if l.i >= len(l.b) { return tEOF } @@ -64,7 +64,7 @@ C [^\n] HELP[\t ]+ l.state = sMeta1; return tHelp TYPE[\t ]+ l.state = sMeta1; return tType {M}({M}|{D})* l.state = sMeta2; return tMName -{C}+ l.state = sInit; return tText +{C}* l.state = sInit; return tText {M}({M}|{D})* l.state = sValue; return tMName \{ l.state = sLabels; return tBraceOpen @@ -87,7 +87,7 @@ C [^\n] return tInvalid } -func (l *lexer) consumeComment() token { +func (l *promlexer) consumeComment() token { for c := l.cur(); ; c = l.next() { switch c { case 0: diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/lex.l.go b/vendor/github.com/prometheus/prometheus/pkg/textparse/promlex.l.go similarity index 98% rename from vendor/github.com/prometheus/prometheus/pkg/textparse/lex.l.go rename to vendor/github.com/prometheus/prometheus/pkg/textparse/promlex.l.go index 33a6a9fc..843feefc 100644 --- a/vendor/github.com/prometheus/prometheus/pkg/textparse/lex.l.go +++ b/vendor/github.com/prometheus/prometheus/pkg/textparse/promlex.l.go @@ -1,4 +1,4 @@ -// Code generated by golex. DO NOT EDIT. +// CAUTION: Generated file - DO NOT EDIT. // Copyright 2017 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); @@ -33,7 +33,7 @@ const ( // Lex is called by the parser generated by "go tool yacc" to obtain each // token. The method is opened before the matching rules block and closed at // the end of the file. -func (l *lexer) Lex() token { +func (l *promlexer) Lex() token { if l.i >= len(l.b) { return tEOF } @@ -260,7 +260,7 @@ yystate21: yystart21: switch { default: - goto yyabort + goto yyrule9 case c == '\t' || c == ' ': goto yystate23 case c >= '\x01' && c <= '\b' || c >= '\v' && c <= '\x1f' || c >= '!' && c <= 'ÿ': @@ -463,7 +463,7 @@ yyrule8: // {M}({M}|{D})* return tMName goto yystate0 } -yyrule9: // {C}+ +yyrule9: // {C}* { l.state = sInit return tText @@ -537,7 +537,7 @@ yyabort: // no lexem recognized return tInvalid } -func (l *lexer) consumeComment() token { +func (l *promlexer) consumeComment() token { for c := l.cur(); ; c = l.next() { switch c { case 0: diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/parse.go b/vendor/github.com/prometheus/prometheus/pkg/textparse/promparse.go similarity index 81% rename from vendor/github.com/prometheus/prometheus/pkg/textparse/parse.go rename to vendor/github.com/prometheus/prometheus/pkg/textparse/promparse.go index 4bc3e137..2b2cbdab 100644 --- a/vendor/github.com/prometheus/prometheus/pkg/textparse/parse.go +++ b/vendor/github.com/prometheus/prometheus/pkg/textparse/promparse.go @@ -12,9 +12,8 @@ // limitations under the License. //go:generate go get github.com/cznic/golex -//go:generate golex -o=lex.l.go lex.l +//go:generate golex -o=promlex.l.go promlex.l -// Package textparse contains an efficient parser for the Prometheus text format. package textparse import ( @@ -28,12 +27,11 @@ import ( "unicode/utf8" "unsafe" - "github.com/prometheus/prometheus/pkg/value" - "github.com/prometheus/prometheus/pkg/labels" + "github.com/prometheus/prometheus/pkg/value" ) -type lexer struct { +type promlexer struct { b []byte i int start int @@ -50,6 +48,8 @@ const ( tWhitespace tHelp tType + tUnit + tEofWord tText tComment tBlank @@ -78,6 +78,10 @@ func (t token) String() string { return "HELP" case tType: return "TYPE" + case tUnit: + return "UNIT" + case tEofWord: + return "EOFWORD" case tText: return "TEXT" case tComment: @@ -107,37 +111,37 @@ func (t token) String() string { } // buf returns the buffer of the current token. -func (l *lexer) buf() []byte { +func (l *promlexer) buf() []byte { return l.b[l.start:l.i] } -func (l *lexer) cur() byte { +func (l *promlexer) cur() byte { return l.b[l.i] } -// next advances the lexer to the next character. -func (l *lexer) next() byte { +// next advances the promlexer to the next character. +func (l *promlexer) next() byte { l.i++ if l.i >= len(l.b) { l.err = io.EOF return byte(tEOF) } - // Lex struggles with null bytes. If we are in a label value, where + // Lex struggles with null bytes. If we are in a label value or help string, where // they are allowed, consume them here immediately. - for l.b[l.i] == 0 && l.state == sLValue { + for l.b[l.i] == 0 && (l.state == sLValue || l.state == sMeta2 || l.state == sComment) { l.i++ } return l.b[l.i] } -func (l *lexer) Error(es string) { +func (l *promlexer) Error(es string) { l.err = errors.New(es) } -// Parser parses samples from a byte slice of samples in the official +// PromParser parses samples from a byte slice of samples in the official // Prometheus text exposition format. -type Parser struct { - l *lexer +type PromParser struct { + l *promlexer series []byte text []byte mtype MetricType @@ -149,13 +153,13 @@ type Parser struct { } // New returns a new parser of the byte slice. -func New(b []byte) *Parser { - return &Parser{l: &lexer{b: append(b, '\n')}} +func NewPromParser(b []byte) Parser { + return &PromParser{l: &promlexer{b: append(b, '\n')}} } // Series returns the bytes of the series, the timestamp if set, and the value // of the current sample. -func (p *Parser) Series() ([]byte, *int64, float64) { +func (p *PromParser) Series() ([]byte, *int64, float64) { if p.hasTS { return p.series, &p.ts, p.val } @@ -165,7 +169,7 @@ func (p *Parser) Series() ([]byte, *int64, float64) { // Help returns the metric name and help text in the current entry. // Must only be called after Next returned a help entry. // The returned byte slices become invalid after the next call to Next. -func (p *Parser) Help() ([]byte, []byte) { +func (p *PromParser) Help() ([]byte, []byte) { m := p.l.b[p.offsets[0]:p.offsets[1]] // Replacer causes allocations. Replace only when necessary. @@ -178,20 +182,28 @@ func (p *Parser) Help() ([]byte, []byte) { // Type returns the metric name and type in the current entry. // Must only be called after Next returned a type entry. // The returned byte slices become invalid after the next call to Next. -func (p *Parser) Type() ([]byte, MetricType) { +func (p *PromParser) Type() ([]byte, MetricType) { return p.l.b[p.offsets[0]:p.offsets[1]], p.mtype } +// Unit returns the metric name and unit in the current entry. +// Must only be called after Next returned a unit entry. +// The returned byte slices become invalid after the next call to Next. +func (p *PromParser) Unit() ([]byte, []byte) { + // The Prometheus format does not have units. + return nil, nil +} + // Comment returns the text of the current comment. // Must only be called after Next returned a comment entry. // The returned byte slice becomes invalid after the next call to Next. -func (p *Parser) Comment() []byte { +func (p *PromParser) Comment() []byte { return p.text } // Metric writes the labels of the current sample into the passed labels. // It returns the string from which the metric was parsed. -func (p *Parser) Metric(l *labels.Labels) string { +func (p *PromParser) Metric(l *labels.Labels) string { // Allocate the full immutable string immediately, so we just // have to create references on it below. s := string(p.series) @@ -222,9 +234,9 @@ func (p *Parser) Metric(l *labels.Labels) string { return s } -// nextToken returns the next token from the lexer. It skips over tabs +// nextToken returns the next token from the promlexer. It skips over tabs // and spaces. -func (p *Parser) nextToken() token { +func (p *PromParser) nextToken() token { for { if tok := p.l.Lex(); tok != tWhitespace { return tok @@ -232,35 +244,13 @@ func (p *Parser) nextToken() token { } } -// Entry represents the type of a parsed entry. -type Entry int - -const ( - EntryInvalid Entry = -1 - EntryType Entry = 0 - EntryHelp Entry = 1 - EntrySeries Entry = 2 - EntryComment Entry = 3 -) - -// MetricType represents metric type values. -type MetricType string - -const ( - MetricTypeCounter = "counter" - MetricTypeGauge = "gauge" - MetricTypeHistogram = "histogram" - MetricTypeSummary = "summary" - MetricTypeUntyped = "untyped" -) - func parseError(exp string, got token) error { return fmt.Errorf("%s, got %q", exp, got) } // Next advances the parser to the next sample. It returns false if no // more samples were read or an error occurred. -func (p *Parser) Next() (Entry, error) { +func (p *PromParser) Next() (Entry, error) { var err error p.start = p.l.i @@ -282,11 +272,16 @@ func (p *Parser) Next() (Entry, error) { } switch t := p.nextToken(); t { case tText: - p.text = p.l.buf()[1:] + if len(p.l.buf()) > 1 { + p.text = p.l.buf()[1:] + } else { + p.text = []byte{} + } default: return EntryInvalid, parseError("expected text in HELP", t) } - if t == tType { + switch t { + case tType: switch s := yoloString(p.text); s { case "counter": p.mtype = MetricTypeCounter @@ -297,10 +292,14 @@ func (p *Parser) Next() (Entry, error) { case "summary": p.mtype = MetricTypeSummary case "untyped": - p.mtype = MetricTypeUntyped + p.mtype = MetricTypeUnknown default: return EntryInvalid, fmt.Errorf("invalid metric type %q", s) } + case tHelp: + if !utf8.Valid(p.text) { + return EntryInvalid, fmt.Errorf("help text is not a valid utf8 string") + } } if t := p.nextToken(); t != tLinebreak { return EntryInvalid, parseError("linebreak expected after metadata", t) @@ -363,7 +362,7 @@ func (p *Parser) Next() (Entry, error) { return EntryInvalid, err } -func (p *Parser) parseLVals() error { +func (p *PromParser) parseLVals() error { t := p.nextToken() for { switch t { @@ -385,7 +384,7 @@ func (p *Parser) parseLVals() error { return fmt.Errorf("invalid UTF-8 label value") } - // The lexer ensures the value string is quoted. Strip first + // The promlexer ensures the value string is quoted. Strip first // and last character. p.offsets = append(p.offsets, p.l.start+1, p.l.i-1) diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/testdata.nometa.txt b/vendor/github.com/prometheus/prometheus/pkg/textparse/promtestdata.nometa.txt similarity index 99% rename from vendor/github.com/prometheus/prometheus/pkg/textparse/testdata.nometa.txt rename to vendor/github.com/prometheus/prometheus/pkg/textparse/promtestdata.nometa.txt index e760ad26..235f0aa4 100644 --- a/vendor/github.com/prometheus/prometheus/pkg/textparse/testdata.nometa.txt +++ b/vendor/github.com/prometheus/prometheus/pkg/textparse/promtestdata.nometa.txt @@ -408,3 +408,4 @@ prometheus_target_sync_length_seconds_sum{scrape_job="prometheus"} 0.00020043300 prometheus_target_sync_length_seconds_count{scrape_job="prometheus"} 1 prometheus_treecache_watcher_goroutines 0 prometheus_treecache_zookeeper_failures_total 0 +# EOF diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/testdata.txt b/vendor/github.com/prometheus/prometheus/pkg/textparse/promtestdata.txt similarity index 99% rename from vendor/github.com/prometheus/prometheus/pkg/textparse/testdata.txt rename to vendor/github.com/prometheus/prometheus/pkg/textparse/promtestdata.txt index c7f2a7af..174f383e 100644 --- a/vendor/github.com/prometheus/prometheus/pkg/textparse/testdata.txt +++ b/vendor/github.com/prometheus/prometheus/pkg/textparse/promtestdata.txt @@ -525,4 +525,5 @@ prometheus_target_sync_length_seconds_count{scrape_job="prometheus"} 1 prometheus_treecache_watcher_goroutines 0 # HELP prometheus_treecache_zookeeper_failures_total The total number of ZooKeeper failures. # TYPE prometheus_treecache_zookeeper_failures_total counter -prometheus_treecache_zookeeper_failures_total 0 \ No newline at end of file +prometheus_treecache_zookeeper_failures_total 0 +# EOF diff --git a/vendor/github.com/prometheus/prometheus/scrape/manager.go b/vendor/github.com/prometheus/prometheus/scrape/manager.go index 4c576952..8cf75d9e 100644 --- a/vendor/github.com/prometheus/prometheus/scrape/manager.go +++ b/vendor/github.com/prometheus/prometheus/scrape/manager.go @@ -14,9 +14,9 @@ package scrape import ( - "fmt" "reflect" "sync" + "time" "github.com/go-kit/kit/log" "github.com/go-kit/kit/log/level" @@ -33,13 +33,16 @@ type Appendable interface { // NewManager is the Manager constructor func NewManager(logger log.Logger, app Appendable) *Manager { + if logger == nil { + logger = log.NewNopLogger() + } return &Manager{ append: app, logger: logger, scrapeConfigs: make(map[string]*config.ScrapeConfig), scrapePools: make(map[string]*scrapePool), graceShut: make(chan struct{}), - targetsAll: make(map[string][]*Target), + triggerReload: make(chan struct{}, 1), } } @@ -50,28 +53,83 @@ type Manager struct { append Appendable graceShut chan struct{} - mtxTargets sync.Mutex // Guards the fields below. - targetsActive []*Target - targetsDropped []*Target - targetsAll map[string][]*Target - mtxScrape sync.Mutex // Guards the fields below. scrapeConfigs map[string]*config.ScrapeConfig scrapePools map[string]*scrapePool + targetSets map[string][]*targetgroup.Group + + triggerReload chan struct{} } -// Run starts background processing to handle target updates and reload the scraping loops. +// Run receives and saves target set updates and triggers the scraping loops reloading. +// Reloading happens in the background so that it doesn't block receiving targets updates. func (m *Manager) Run(tsets <-chan map[string][]*targetgroup.Group) error { + go m.reloader() for { select { case ts := <-tsets: - m.reload(ts) + m.updateTsets(ts) + + select { + case m.triggerReload <- struct{}{}: + default: + } + case <-m.graceShut: return nil } } } +func (m *Manager) reloader() { + ticker := time.NewTicker(5 * time.Second) + defer ticker.Stop() + + for { + select { + case <-m.graceShut: + return + case <-ticker.C: + select { + case <-m.triggerReload: + m.reload() + case <-m.graceShut: + return + } + } + } +} + +func (m *Manager) reload() { + m.mtxScrape.Lock() + var wg sync.WaitGroup + for setName, groups := range m.targetSets { + var sp *scrapePool + existing, ok := m.scrapePools[setName] + if !ok { + scrapeConfig, ok := m.scrapeConfigs[setName] + if !ok { + level.Error(m.logger).Log("msg", "error reloading target set", "err", "invalid config id:"+setName) + return + } + sp = newScrapePool(scrapeConfig, m.append, log.With(m.logger, "scrape_pool", setName)) + m.scrapePools[setName] = sp + } else { + sp = existing + } + + wg.Add(1) + // Run the sync in parallel as these take a while and at high load can't catch up. + go func(sp *scrapePool, groups []*targetgroup.Group) { + sp.Sync(groups) + wg.Done() + }(sp, groups) + + } + m.mtxScrape.Unlock() + wg.Wait() +} + // Stop cancels all running scrape pools and blocks until all have exited. func (m *Manager) Stop() { m.mtxScrape.Lock() @@ -83,6 +141,12 @@ func (m *Manager) Stop() { close(m.graceShut) } +func (m *Manager) updateTsets(tsets map[string][]*targetgroup.Group) { + m.mtxScrape.Lock() + m.targetSets = tsets + m.mtxScrape.Unlock() +} + // ApplyConfig resets the manager's target providers and job configurations as defined by the new cfg. func (m *Manager) ApplyConfig(cfg *config.Config) error { m.mtxScrape.Lock() @@ -109,64 +173,37 @@ func (m *Manager) ApplyConfig(cfg *config.Config) error { // TargetsAll returns active and dropped targets grouped by job_name. func (m *Manager) TargetsAll() map[string][]*Target { - m.mtxTargets.Lock() - defer m.mtxTargets.Unlock() - return m.targetsAll -} + m.mtxScrape.Lock() + defer m.mtxScrape.Unlock() -// TargetsActive returns the active targets currently being scraped. -func (m *Manager) TargetsActive() []*Target { - m.mtxTargets.Lock() - defer m.mtxTargets.Unlock() - return m.targetsActive -} + targets := make(map[string][]*Target, len(m.scrapePools)) + for tset, sp := range m.scrapePools { + targets[tset] = append(sp.ActiveTargets(), sp.DroppedTargets()...) -// TargetsDropped returns the dropped targets during relabelling. -func (m *Manager) TargetsDropped() []*Target { - m.mtxTargets.Lock() - defer m.mtxTargets.Unlock() - return m.targetsDropped + } + return targets } -func (m *Manager) targetsUpdate(active, dropped map[string][]*Target) { - m.mtxTargets.Lock() - defer m.mtxTargets.Unlock() - - m.targetsAll = make(map[string][]*Target) - m.targetsActive = nil - m.targetsDropped = nil - for jobName, targets := range active { - m.targetsAll[jobName] = append(m.targetsAll[jobName], targets...) - m.targetsActive = append(m.targetsActive, targets...) +// TargetsActive returns the active targets currently being scraped. +func (m *Manager) TargetsActive() map[string][]*Target { + m.mtxScrape.Lock() + defer m.mtxScrape.Unlock() + targets := make(map[string][]*Target, len(m.scrapePools)) + for tset, sp := range m.scrapePools { + targets[tset] = sp.ActiveTargets() } - for jobName, targets := range dropped { - m.targetsAll[jobName] = append(m.targetsAll[jobName], targets...) - m.targetsDropped = append(m.targetsDropped, targets...) - } + return targets } -func (m *Manager) reload(t map[string][]*targetgroup.Group) { +// TargetsDropped returns the dropped targets during relabelling. +func (m *Manager) TargetsDropped() map[string][]*Target { m.mtxScrape.Lock() defer m.mtxScrape.Unlock() - tDropped := make(map[string][]*Target) - tActive := make(map[string][]*Target) - - for tsetName, tgroup := range t { - var sp *scrapePool - if existing, ok := m.scrapePools[tsetName]; !ok { - scrapeConfig, ok := m.scrapeConfigs[tsetName] - if !ok { - level.Error(m.logger).Log("msg", "error reloading target set", "err", fmt.Sprintf("invalid config id:%v", tsetName)) - continue - } - sp = newScrapePool(scrapeConfig, m.append, log.With(m.logger, "scrape_pool", tsetName)) - m.scrapePools[tsetName] = sp - } else { - sp = existing - } - tActive[tsetName], tDropped[tsetName] = sp.Sync(tgroup) + targets := make(map[string][]*Target, len(m.scrapePools)) + for tset, sp := range m.scrapePools { + targets[tset] = sp.DroppedTargets() } - m.targetsUpdate(tActive, tDropped) + return targets } diff --git a/vendor/github.com/prometheus/prometheus/scrape/scrape.go b/vendor/github.com/prometheus/prometheus/scrape/scrape.go index 1b493696..3060c34a 100644 --- a/vendor/github.com/prometheus/prometheus/scrape/scrape.go +++ b/vendor/github.com/prometheus/prometheus/scrape/scrape.go @@ -124,7 +124,7 @@ type scrapePool struct { client *http.Client // Targets and loops must always be synchronized to have the same // set of hashes. - targets map[uint64]*Target + activeTargets map[uint64]*Target droppedTargets []*Target loops map[uint64]loop cancel context.CancelFunc @@ -152,13 +152,13 @@ func newScrapePool(cfg *config.ScrapeConfig, app Appendable, logger log.Logger) ctx, cancel := context.WithCancel(context.Background()) sp := &scrapePool{ - cancel: cancel, - appendable: app, - config: cfg, - client: client, - targets: map[uint64]*Target{}, - loops: map[uint64]loop{}, - logger: logger, + cancel: cancel, + appendable: app, + config: cfg, + client: client, + activeTargets: map[uint64]*Target{}, + loops: map[uint64]loop{}, + logger: logger, } sp.newLoop = func(t *Target, s scraper, limit int, honor bool, mrc []*config.RelabelConfig) loop { // Update the targets retrieval function for metadata to a new scrape cache. @@ -186,6 +186,23 @@ func newScrapePool(cfg *config.ScrapeConfig, app Appendable, logger log.Logger) return sp } +func (sp *scrapePool) ActiveTargets() []*Target { + sp.mtx.Lock() + defer sp.mtx.Unlock() + + var tActive []*Target + for _, t := range sp.activeTargets { + tActive = append(tActive, t) + } + return tActive +} + +func (sp *scrapePool) DroppedTargets() []*Target { + sp.mtx.Lock() + defer sp.mtx.Unlock() + return sp.droppedTargets +} + // stop terminates all scrape loops and returns after they all terminated. func (sp *scrapePool) stop() { sp.cancel() @@ -203,7 +220,7 @@ func (sp *scrapePool) stop() { }(l) delete(sp.loops, fp) - delete(sp.targets, fp) + delete(sp.activeTargets, fp) } wg.Wait() } @@ -236,7 +253,7 @@ func (sp *scrapePool) reload(cfg *config.ScrapeConfig) { for fp, oldLoop := range sp.loops { var ( - t = sp.targets[fp] + t = sp.activeTargets[fp] s = &targetScraper{Target: t, client: sp.client, timeout: timeout} newLoop = sp.newLoop(t, s, limit, honor, mrc) ) @@ -260,7 +277,7 @@ func (sp *scrapePool) reload(cfg *config.ScrapeConfig) { // Sync converts target groups into actual scrape targets and synchronizes // the currently running scraper with the resulting set and returns all scraped and dropped targets. -func (sp *scrapePool) Sync(tgs []*targetgroup.Group) (tActive []*Target, tDropped []*Target) { +func (sp *scrapePool) Sync(tgs []*targetgroup.Group) { start := time.Now() var all []*Target @@ -287,15 +304,6 @@ func (sp *scrapePool) Sync(tgs []*targetgroup.Group) (tActive []*Target, tDroppe time.Since(start).Seconds(), ) targetScrapePoolSyncsCounter.WithLabelValues(sp.config.JobName).Inc() - - sp.mtx.RLock() - for _, t := range sp.targets { - tActive = append(tActive, t) - } - tDropped = sp.droppedTargets - sp.mtx.RUnlock() - - return tActive, tDropped } // sync takes a list of potentially duplicated targets, deduplicates them, starts @@ -319,34 +327,36 @@ func (sp *scrapePool) sync(targets []*Target) { hash := t.hash() uniqueTargets[hash] = struct{}{} - if _, ok := sp.targets[hash]; !ok { + if _, ok := sp.activeTargets[hash]; !ok { s := &targetScraper{Target: t, client: sp.client, timeout: timeout} l := sp.newLoop(t, s, limit, honor, mrc) - sp.targets[hash] = t + sp.activeTargets[hash] = t sp.loops[hash] = l go l.run(interval, timeout, nil) } else { // Need to keep the most updated labels information // for displaying it in the Service Discovery web page. - sp.targets[hash].SetDiscoveredLabels(t.DiscoveredLabels()) + sp.activeTargets[hash].SetDiscoveredLabels(t.DiscoveredLabels()) } } var wg sync.WaitGroup // Stop and remove old targets and scraper loops. - for hash := range sp.targets { + for hash := range sp.activeTargets { if _, ok := uniqueTargets[hash]; !ok { wg.Add(1) go func(l loop) { + l.stop() + wg.Done() }(sp.loops[hash]) delete(sp.loops, hash) - delete(sp.targets, hash) + delete(sp.activeTargets, hash) } } @@ -424,7 +434,7 @@ func appender(app storage.Appender, limit int) storage.Appender { // A scraper retrieves samples and accepts a status report at the end. type scraper interface { - scrape(ctx context.Context, w io.Writer) error + scrape(ctx context.Context, w io.Writer) (string, error) report(start time.Time, dur time.Duration, err error) offset(interval time.Duration) time.Duration } @@ -441,15 +451,15 @@ type targetScraper struct { buf *bufio.Reader } -const acceptHeader = `text/plain;version=0.0.4;q=1,*/*;q=0.1` +const acceptHeader = `application/openmetrics-text; version=0.0.1,text/plain;version=0.0.4;q=0.5,*/*;q=0.1` var userAgentHeader = fmt.Sprintf("Prometheus/%s", version.Version) -func (s *targetScraper) scrape(ctx context.Context, w io.Writer) error { +func (s *targetScraper) scrape(ctx context.Context, w io.Writer) (string, error) { if s.req == nil { req, err := http.NewRequest("GET", s.URL().String(), nil) if err != nil { - return err + return "", err } req.Header.Add("Accept", acceptHeader) req.Header.Add("Accept-Encoding", "gzip") @@ -461,33 +471,38 @@ func (s *targetScraper) scrape(ctx context.Context, w io.Writer) error { resp, err := ctxhttp.Do(ctx, s.client, s.req) if err != nil { - return err + return "", err } defer resp.Body.Close() if resp.StatusCode != http.StatusOK { - return fmt.Errorf("server returned HTTP status %s", resp.Status) + return "", fmt.Errorf("server returned HTTP status %s", resp.Status) } if resp.Header.Get("Content-Encoding") != "gzip" { _, err = io.Copy(w, resp.Body) - return err + return "", err } if s.gzipr == nil { s.buf = bufio.NewReader(resp.Body) s.gzipr, err = gzip.NewReader(s.buf) if err != nil { - return err + return "", err } } else { s.buf.Reset(resp.Body) - s.gzipr.Reset(s.buf) + if err = s.gzipr.Reset(s.buf); err != nil { + return "", err + } } _, err = io.Copy(w, s.gzipr) s.gzipr.Close() - return err + if err != nil { + return "", err + } + return resp.Header.Get("Content-Type"), nil } // A loop can run and be stopped again. It must not be reused after it was stopped. @@ -547,9 +562,10 @@ type scrapeCache struct { // metaEntry holds meta information about a metric. type metaEntry struct { - lastIter uint64 // last scrape iteration the entry was observed + lastIter uint64 // Last scrape iteration the entry was observed at. typ textparse.MetricType help string + unit string } func newScrapeCache() *scrapeCache { @@ -644,7 +660,7 @@ func (c *scrapeCache) setType(metric []byte, t textparse.MetricType) { e, ok := c.metadata[yoloString(metric)] if !ok { - e = &metaEntry{typ: textparse.MetricTypeUntyped} + e = &metaEntry{typ: textparse.MetricTypeUnknown} c.metadata[string(metric)] = e } e.typ = t @@ -658,7 +674,7 @@ func (c *scrapeCache) setHelp(metric, help []byte) { e, ok := c.metadata[yoloString(metric)] if !ok { - e = &metaEntry{typ: textparse.MetricTypeUntyped} + e = &metaEntry{typ: textparse.MetricTypeUnknown} c.metadata[string(metric)] = e } if e.help != yoloString(help) { @@ -669,6 +685,22 @@ func (c *scrapeCache) setHelp(metric, help []byte) { c.metaMtx.Unlock() } +func (c *scrapeCache) setUnit(metric, unit []byte) { + c.metaMtx.Lock() + + e, ok := c.metadata[yoloString(metric)] + if !ok { + e = &metaEntry{typ: textparse.MetricTypeUnknown} + c.metadata[string(metric)] = e + } + if e.unit != yoloString(unit) { + e.unit = string(unit) + } + e.lastIter = c.iter + + c.metaMtx.Unlock() +} + func (c *scrapeCache) getMetadata(metric string) (MetricMetadata, bool) { c.metaMtx.Lock() defer c.metaMtx.Unlock() @@ -681,6 +713,7 @@ func (c *scrapeCache) getMetadata(metric string) (MetricMetadata, bool) { Metric: metric, Type: m.typ, Help: m.help, + Unit: m.unit, }, true } @@ -695,6 +728,7 @@ func (c *scrapeCache) listMetadata() []MetricMetadata { Metric: m, Type: e.typ, Help: e.help, + Unit: e.unit, }) } return res @@ -777,7 +811,7 @@ mainLoop: b := sl.buffers.Get(sl.lastScrapeSize).([]byte) buf := bytes.NewBuffer(b) - scrapeErr := sl.scraper.scrape(scrapeCtx, buf) + contentType, scrapeErr := sl.scraper.scrape(scrapeCtx, buf) cancel() if scrapeErr == nil { @@ -797,12 +831,12 @@ mainLoop: // A failed scrape is the same as an empty scrape, // we still call sl.append to trigger stale markers. - total, added, appErr := sl.append(b, start) + total, added, appErr := sl.append(b, contentType, start) if appErr != nil { level.Warn(sl.l).Log("msg", "append failed", "err", appErr) // The append failed, probably due to a parse error or sample limit. // Call sl.append again with an empty scrape to trigger stale markers. - if _, _, err := sl.append([]byte{}, start); err != nil { + if _, _, err := sl.append([]byte{}, "", start); err != nil { level.Warn(sl.l).Log("msg", "append failed", "err", err) } } @@ -813,7 +847,9 @@ mainLoop: scrapeErr = appErr } - sl.report(start, time.Since(start), total, added, scrapeErr) + if err := sl.report(start, time.Since(start), total, added, scrapeErr); err != nil { + level.Warn(sl.l).Log("msg", "appending scrape report failed", "err", err) + } last = start select { @@ -871,7 +907,7 @@ func (sl *scrapeLoop) endOfRunStaleness(last time.Time, ticker *time.Ticker, int // Call sl.append again with an empty scrape to trigger stale markers. // If the target has since been recreated and scraped, the // stale markers will be out of order and ignored. - if _, _, err := sl.append([]byte{}, staleTime); err != nil { + if _, _, err := sl.append([]byte{}, "", staleTime); err != nil { level.Error(sl.l).Log("msg", "stale append failed", "err", err) } if err := sl.reportStale(staleTime); err != nil { @@ -907,10 +943,10 @@ func (s samples) Less(i, j int) bool { return s[i].t < s[j].t } -func (sl *scrapeLoop) append(b []byte, ts time.Time) (total, added int, err error) { +func (sl *scrapeLoop) append(b []byte, contentType string, ts time.Time) (total, added int, err error) { var ( app = sl.appender() - p = textparse.New(b) + p = textparse.New(b, contentType) defTime = timestamp.FromTime(ts) numOutOfOrder = 0 numDuplicates = 0 @@ -934,6 +970,9 @@ loop: case textparse.EntryHelp: sl.cache.setHelp(p.Help()) continue + case textparse.EntryUnit: + sl.cache.setUnit(p.Unit()) + continue case textparse.EntryComment: continue default: diff --git a/vendor/github.com/prometheus/prometheus/scrape/target.go b/vendor/github.com/prometheus/prometheus/scrape/target.go index 0528e384..3502dcf9 100644 --- a/vendor/github.com/prometheus/prometheus/scrape/target.go +++ b/vendor/github.com/prometheus/prometheus/scrape/target.go @@ -53,11 +53,12 @@ type Target struct { // Additional URL parmeters that are part of the target URL. params url.Values - mtx sync.RWMutex - lastError error - lastScrape time.Time - health TargetHealth - metadata metricMetadataStore + mtx sync.RWMutex + lastError error + lastScrape time.Time + lastScrapeDuration time.Duration + health TargetHealth + metadata metricMetadataStore } // NewTarget creates a reasonably configured target for querying. @@ -84,6 +85,7 @@ type MetricMetadata struct { Metric string Type textparse.MetricType Help string + Unit string } func (t *Target) MetadataList() []MetricMetadata { @@ -206,6 +208,7 @@ func (t *Target) report(start time.Time, dur time.Duration, err error) { t.lastError = err t.lastScrape = start + t.lastScrapeDuration = dur } // LastError returns the error encountered during the last scrape. @@ -224,6 +227,14 @@ func (t *Target) LastScrape() time.Time { return t.lastScrape } +// LastScrapeDuration returns how long the last scrape of the target took. +func (t *Target) LastScrapeDuration() time.Duration { + t.mtx.RLock() + defer t.mtx.RUnlock() + + return t.lastScrapeDuration +} + // Health returns the last known health state of the target. func (t *Target) Health() TargetHealth { t.mtx.RLock() diff --git a/vendor/vendor.json b/vendor/vendor.json index 787c9f9b..a8605f86 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -780,10 +780,10 @@ "revisionTime": "2018-06-05T10:30:19Z" }, { - "checksumSHA1": "zkMYxyNMJLOL05bHwKpzzFNrWgk=", + "checksumSHA1": "Gryza0KJX4i6dS6UYr/DBtvEWa0=", "path": "github.com/prometheus/prometheus/pkg/textparse", - "revision": "ae96914199b4e1e47b27a3789c3044ee8a14e796", - "revisionTime": "2018-06-05T10:30:19Z" + "revision": "67dc912ac8b24f94a1fc478f352d25179c94ab9b", + "revisionTime": "2018-11-06T11:38:56Z" }, { "checksumSHA1": "aBxiHq8WBoLD+8U0/PxdWufs64o=", @@ -798,10 +798,10 @@ "revisionTime": "2018-06-05T10:30:19Z" }, { - "checksumSHA1": "AJaBokB3sohb8Cv+QJAaJq9ysfU=", + "checksumSHA1": "+MySwSXOb6nwbb3tQi3GaVxDHbM=", "path": "github.com/prometheus/prometheus/scrape", - "revision": "ae96914199b4e1e47b27a3789c3044ee8a14e796", - "revisionTime": "2018-06-05T10:30:19Z" + "revision": "67dc912ac8b24f94a1fc478f352d25179c94ab9b", + "revisionTime": "2018-11-06T11:38:56Z" }, { "checksumSHA1": "xYVbgwVChu2859wdb9cwqEokcR4=", From ec7958fd955aaddfec02d92c2ef5acea7dab38b7 Mon Sep 17 00:00:00 2001 From: Fabian Reinartz Date: Thu, 8 Nov 2018 06:58:43 -0500 Subject: [PATCH 3/4] Handle Prometheus 2.5 unknown metric type Signed-off-by: Fabian Reinartz --- README.md | 7 ++++--- cmd/stackdriver-prometheus-sidecar/main.go | 7 +++++-- metadata/cache.go | 12 ++++++++++++ metadata/cache_test.go | 19 ++++++++++++++++++- retrieval/series_cache.go | 2 +- retrieval/transform.go | 2 +- retrieval/transform_test.go | 2 +- 7 files changed, 42 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index b5d0fab8..d1a8de3d 100644 --- a/README.md +++ b/README.md @@ -49,9 +49,10 @@ can be used as a reference for setup: The matrix below lists the versions of Prometheus Server and other dependencies that have been qualified to work with releases of `stackdriver-prometheus-sidecar`. -| sidecar version | prometheus version | -| --- | --- | -| 0.2.x | 2.4.3 | +| sidecar version | **Prometheus 2.4.3** | **Prometheus 2.5.x** | +|------------|------------------|-------------------| +| **0.2.x** | ✓ | - | +| **master** | ✓ | ✓ | ## Source Code Headers diff --git a/cmd/stackdriver-prometheus-sidecar/main.go b/cmd/stackdriver-prometheus-sidecar/main.go index a9bdf705..691c4a69 100644 --- a/cmd/stackdriver-prometheus-sidecar/main.go +++ b/cmd/stackdriver-prometheus-sidecar/main.go @@ -613,8 +613,11 @@ func parseConfigFile(filename string) (map[string]string, []scrape.MetricMetadat var staticMetadata []scrape.MetricMetadata for _, sm := range fc.StaticMetadata { switch sm.Type { - case textparse.MetricTypeCounter, textparse.MetricTypeGauge, - textparse.MetricTypeHistogram, textparse.MetricTypeSummary, textparse.MetricTypeUntyped: + case metadata.MetricTypeUntyped: + // Convert "untyped" to the "unknown" type used internally as of Prometheus 2.5. + sm.Type = textparse.MetricTypeUnknown + case textparse.MetricTypeCounter, textparse.MetricTypeGauge, textparse.MetricTypeHistogram, + textparse.MetricTypeSummary, textparse.MetricTypeUnknown: default: return nil, nil, errors.Errorf("invalid metric type %q", sm.Type) } diff --git a/metadata/cache.go b/metadata/cache.go index 36b0ac1a..9015d082 100644 --- a/metadata/cache.go +++ b/metadata/cache.go @@ -46,6 +46,10 @@ type Cache struct { // the target metadata endpoint. const DefaultEndpointPath = "/api/v1/targets/metadata" +// The old metric type value for textparse.MetricTypeUnknown that is used in +// Prometheus 2.4 and earlier. +const MetricTypeUntyped = "untyped" + // NewCache returns a new cache that gets populated by the metadata endpoint // at the given URL. // It uses the default endpoint path if no specific path is provided. @@ -176,6 +180,10 @@ func (c *Cache) fetchMetric(ctx context.Context, job, instance, metric string) ( } d := apiResp.Data[0] + // Convert legacy "untyped" type used before Prometheus 2.5. + if d.Type == MetricTypeUntyped { + d.Type = textparse.MetricTypeUnknown + } return &metadataEntry{ MetricMetadata: scrape.MetricMetadata{ Metric: metric, @@ -212,6 +220,10 @@ func (c *Cache) fetchBatch(ctx context.Context, job, instance string) (map[strin result := make(map[string]*metadataEntry, len(apiResp.Data)+len(internalMetrics)) for _, md := range apiResp.Data { + // Convert legacy "untyped" type used before Prometheus 2.5. + if md.Type == MetricTypeUntyped { + md.Type = textparse.MetricTypeUnknown + } result[md.Metric] = &metadataEntry{ MetricMetadata: scrape.MetricMetadata{ Metric: md.Metric, diff --git a/metadata/cache_test.go b/metadata/cache_test.go index 34cec44d..89a45ed7 100644 --- a/metadata/cache_test.go +++ b/metadata/cache_test.go @@ -35,7 +35,8 @@ func TestCache_Get(t *testing.T) { {Metric: "metric2", Type: textparse.MetricTypeGauge, Help: "help_metric2"}, {Metric: "metric3", Type: textparse.MetricTypeHistogram, Help: "help_metric3"}, {Metric: "metric4", Type: textparse.MetricTypeSummary, Help: "help_metric4"}, - {Metric: "metric5", Type: textparse.MetricTypeUntyped, Help: "help_metric5"}, + {Metric: "metric5", Type: textparse.MetricTypeUnknown, Help: "help_metric5"}, + {Metric: "metric6", Type: MetricTypeUntyped, Help: "help_metric6"}, } var handler func(qMetric, qMatch string) *apiResponse @@ -129,6 +130,22 @@ func TestCache_Get(t *testing.T) { } expect(metrics[4], md) + // Test "untyped" metric type from Prometheus 2.4. + handler = func(qMetric, qMatch string) *apiResponse { + if qMetric != "metric6" { + t.Fatalf("unexpected metric %q in request", qMetric) + } + if qMatch != `{job="prometheus",instance="localhost:9090"}` { + t.Fatalf("unexpected matcher %q in request", qMatch) + } + return &apiResponse{Status: "success", Data: metrics[5:6]} + } + md, err = c.Get(ctx, "prometheus", "localhost:9090", "metric6") + if err != nil { + t.Fatal(err) + } + expect(apiMetadata{Metric: "metric6", Type: textparse.MetricTypeUnknown, Help: "help_metric6"}, md) + // The scrape layer's metrics should not fire off requests. md, err = c.Get(ctx, "prometheus", "localhost:9090", "up") if err != nil { diff --git a/retrieval/series_cache.go b/retrieval/series_cache.go index a4f528eb..4dfe33fd 100644 --- a/retrieval/series_cache.go +++ b/retrieval/series_cache.go @@ -407,7 +407,7 @@ func (c *seriesCache) refresh(ctx context.Context, ref uint64) error { case textparse.MetricTypeCounter: ts.MetricKind = metric_pb.MetricDescriptor_CUMULATIVE ts.ValueType = metric_pb.MetricDescriptor_DOUBLE - case textparse.MetricTypeGauge, textparse.MetricTypeUntyped: + case textparse.MetricTypeGauge, textparse.MetricTypeUnknown: ts.MetricKind = metric_pb.MetricDescriptor_GAUGE ts.ValueType = metric_pb.MetricDescriptor_DOUBLE case textparse.MetricTypeSummary: diff --git a/retrieval/transform.go b/retrieval/transform.go index ce47a932..58eec3c8 100644 --- a/retrieval/transform.go +++ b/retrieval/transform.go @@ -70,7 +70,7 @@ func (b *sampleBuilder) next(ctx context.Context, samples []tsdb.RefSample) (*mo point.Interval.StartTime = getTimestamp(resetTimestamp) point.Value = &monitoring_pb.TypedValue{&monitoring_pb.TypedValue_DoubleValue{v}} - case textparse.MetricTypeGauge, textparse.MetricTypeUntyped: + case textparse.MetricTypeGauge, textparse.MetricTypeUnknown: point.Value = &monitoring_pb.TypedValue{&monitoring_pb.TypedValue_DoubleValue{sample.V}} case textparse.MetricTypeSummary: diff --git a/retrieval/transform_test.go b/retrieval/transform_test.go index dbdd98d3..60739acf 100644 --- a/retrieval/transform_test.go +++ b/retrieval/transform_test.go @@ -94,7 +94,7 @@ func TestSampleBuilder(t *testing.T) { metadata: metadataMap{ "job1/instance1/metric1": &scrape.MetricMetadata{Type: textparse.MetricTypeGauge, Metric: "metric1"}, "job1/instance1/metric2": &scrape.MetricMetadata{Type: textparse.MetricTypeCounter, Metric: "metric2"}, - "job1/instance1/labelnum_ok": &scrape.MetricMetadata{Type: textparse.MetricTypeUntyped, Metric: "labelnum_ok"}, + "job1/instance1/labelnum_ok": &scrape.MetricMetadata{Type: textparse.MetricTypeUnknown, Metric: "labelnum_ok"}, "job1/instance1/labelnum_bad": &scrape.MetricMetadata{Type: textparse.MetricTypeGauge, Metric: "labelnum_bad"}, }, input: []tsdb.RefSample{ From 9e04d2e071a68ca1ce572bbc82532cb0f4f33a14 Mon Sep 17 00:00:00 2001 From: Fabian Reinartz Date: Thu, 8 Nov 2018 11:48:45 -0500 Subject: [PATCH 4/4] Revert to 2.4.3 until upstream is fixed Signed-off-by: Fabian Reinartz --- kube/prometheus-meta-operated.yaml | 2 +- kube/prometheus-meta.yaml | 2 +- .../prometheus/pkg/textparse/cpu.oput | Bin 32804 -> 0 bytes .../prometheus/pkg/textparse/cpu.out | Bin 16257 -> 0 bytes .../prometheus/pkg/textparse/cpu.svg | 2950 ----------------- 5 files changed, 2 insertions(+), 2952 deletions(-) delete mode 100644 vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.oput delete mode 100644 vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.out delete mode 100644 vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.svg diff --git a/kube/prometheus-meta-operated.yaml b/kube/prometheus-meta-operated.yaml index 4b159986..3749e867 100644 --- a/kube/prometheus-meta-operated.yaml +++ b/kube/prometheus-meta-operated.yaml @@ -15,7 +15,7 @@ spec: matchExpressions: - key: app operator: Exists - version: v2.5.0 + version: v2.4.3 # Inject the sidecar container. containers: - name: sidecar diff --git a/kube/prometheus-meta.yaml b/kube/prometheus-meta.yaml index 32df1b24..6673f621 100644 --- a/kube/prometheus-meta.yaml +++ b/kube/prometheus-meta.yaml @@ -22,7 +22,7 @@ spec: runAsUser: 0 containers: - name: prometheus - image: quay.io/prometheus/prometheus:v2.5.0 + image: quay.io/prometheus/prometheus:v2.4.3 imagePullPolicy: Always args: - "--config.file=/etc/prometheus/config/prometheus.yaml" diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.oput b/vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.oput deleted file mode 100644 index b1ceb88328c4ebe149972724293153423d322adc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 32804 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 diff --git a/vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.svg b/vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.svg deleted file mode 100644 index 3ec8aa70..00000000 --- a/vendor/github.com/prometheus/prometheus/pkg/textparse/cpu.svg +++ /dev/null @@ -1,2950 +0,0 @@ - - - - - - -textparse.test - -cluster_L - - - -File: textparse.test - - -File: textparse.test -Type: cpu -Time: May 25, 2018 at 9:13am (EDT) -Duration: 18.57s, Total samples = 19.78s (106.52%) -Showing nodes accounting for 16.87s, 85.29% of 19.78s total -Dropped 201 nodes (cum <= 0.10s) -Dropped 27 edges (freq <= 0.02s) -Showing top 80 nodes out of 142 - - - - -N1 - - -testing -(*B) -runN -0 of 17.42s (88.07%) - - - - -N2 - - -github -com/prometheus/prometheus/pkg/textparse -(*Parser) -Next -0.33s (1.67%) -of 8.87s (44.84%) - - - - -N1->N2 - - - - - - - 3.61s - - - - -N10 - - -github -com/prometheus/prometheus/pkg/textparse -BenchmarkParse -func2 -0.02s (0.1%) -of 3.81s (19.26%) - - - - -N1->N10 - - - - - - - 3.81s - - - - -N14 - - -github -com/prometheus/prometheus/pkg/textparse -BenchmarkParse -func3 -0 of 3.91s (19.77%) - - - - -N1->N14 - - - - - - - 3.91s - - - - -N27 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/expfmt -(*SampleDecoder) -Decode -0.01s (0.051%) -of 3.17s (16.03%) - - - - -N1->N27 - - - - - - - 3.17s - - - - -N37 - - -github -com/prometheus/prometheus/pkg/textparse -BenchmarkGzip -func1 -0 of 2.90s (14.66%) - - - - -N1->N37 - - - - - - - 2.90s - - - - -N7 - - -github -com/prometheus/prometheus/pkg/textparse -(*Parser) -nextToken -0.27s (1.37%) -of 7.45s (37.66%) - - - - -N2->N7 - - - - - - - 5.04s - - - - -N15 - - -github -com/prometheus/prometheus/pkg/textparse -(*Parser) -parseLVals -0.26s (1.31%) -of 2.93s (14.81%) - - - - -N2->N15 - - - - - - - 2.93s - - - - -N41 - - -strconv -ParseFloat -0.07s (0.35%) -of 0.58s (2.93%) - - - - -N2->N41 - - - - - - - 0.49s - - - - -N55 - - -runtime -gcWriteBarrier -0.04s (0.2%) -of 0.11s (0.56%) - - - - -N2->N55 - - - - - - - 0.02s - - - - -N57 - - -runtime -growslice -0.02s (0.1%) -of 0.18s (0.91%) - - - - -N2->N57 - - - - - - - 0.02s - - - - -N3 - - -testing -(*B) -launch -0 of 17.41s (88.02%) - - - - -N3->N1 - - - - - - - 17.41s - - - - -N4 - - -runtime -mallocgc -0.91s (4.60%) -of 3.27s (16.53%) - - - - -N21 - - -runtime -memclrNoHeapPointers -0.73s (3.69%) - - - - -N4->N21 - - - - - - - 0.03s - - - - -N38 - - -runtime -heapBitsSetType -0.43s (2.17%) -of 0.46s (2.33%) - - - - -N4->N38 - - - - - - - 0.46s - - - - -N51 - - -runtime -nextFreeFast -0.28s (1.42%) - - - - -N4->N51 - - - - - - - 0.28s - (inline) - - - - -N79 - - -runtime -(*mcache) -nextFree -0.03s (0.15%) -of 0.98s (4.95%) - - - - -N4->N79 - - - - - - - 0.98s - - - - -N5 - - -github -com/prometheus/prometheus/pkg/textparse -(*lexer) -Lex -3.83s (19.36%) -of 7.18s (36.30%) - - - - -N11 - - -github -com/prometheus/prometheus/pkg/textparse -(*lexer) -next -2.75s (13.90%) -of 3.35s (16.94%) - - - - -N5->N11 - - - - - - - 3.35s - - - - -N6 - - -runtime -systemstack -0.03s (0.15%) -of 2.68s (13.55%) - - - - -N30 - - -runtime -gcDrain -0.08s (0.4%) -of 0.86s (4.35%) - - - - -N6->N30 - - - - - - - 0.84s - - - - -N44 - - -runtime -heapBitsForObject -0.20s (1.01%) - - - - -N6->N44 - - - - - - - 0.03s - - - - -N47 - - -runtime -notewakeup -0.02s (0.1%) -of 0.38s (1.92%) - - - - -N6->N47 - - - - - - - 0.21s - - - - -N50 - - -runtime -(*mcentral) -cacheSpan -0.01s (0.051%) -of 0.94s (4.75%) - - - - -N6->N50 - - - - - - - 0.94s - - - - -N73 - - -runtime -gcDrainN -0 of 0.24s (1.21%) - - - - -N6->N73 - - - - - - - 0.24s - - - - -N7->N5 - - - - - - - 7.18s - - - - -N8 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/expfmt -(*TextParser) -TextToMetricFamilies -0.01s (0.051%) -of 2.89s (14.61%) - - - - -N12 - - -runtime -newobject -0.06s (0.3%) -of 1.01s (5.11%) - - - - -N8->N12 - - - - - - - 0.12s - - - - -N23 - - -bufio -(*Reader) -ReadByte -0.40s (2.02%) - - - - -N8->N23 - - - - - - - 0.03s - - - - -N26 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/expfmt -(*TextParser) -startLabelName -0.03s (0.15%) -of 0.62s (3.13%) - - - - -N8->N26 - - - - - - - 0.62s - - - - -N29 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/expfmt -(*TextParser) -readingValue -0.04s (0.2%) -of 0.54s (2.73%) - - - - -N8->N29 - - - - - - - 0.54s - - - - -N35 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/expfmt -(*TextParser) -readingMetricName -0 of 0.80s (4.04%) - - - - -N8->N35 - - - - - - - 0.80s - - - - -N36 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/expfmt -(*TextParser) -startLabelValue -0.05s (0.25%) -of 0.41s (2.07%) - - - - -N8->N36 - - - - - - - 0.41s - - - - -N62 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/expfmt -(*TextParser) -startComment -0.01s (0.051%) -of 0.19s (0.96%) - - - - -N8->N62 - - - - - - - 0.19s - - - - -N9 - - -github -com/prometheus/prometheus/pkg/textparse -(*Parser) -Metric -0.26s (1.31%) -of 1.78s (9.00%) - - - - -N25 - - -runtime -slicebytetostring -0.05s (0.25%) -of 0.79s (3.99%) - - - - -N9->N25 - - - - - - - 0.60s - - - - -N9->N55 - - - - - - - 0.03s - - - - -N60 - - -runtime -convT2Islice -0.04s (0.2%) -of 0.53s (2.68%) - - - - -N9->N60 - - - - - - - 0.50s - - - - -N64 - - -sort -Sort -0.03s (0.15%) -of 0.26s (1.31%) - - - - -N9->N64 - - - - - - - 0.25s - - - - -N75 - - -runtime -indexbytebody -0.14s (0.71%) - - - - -N9->N75 - - - - - - - 0.14s - - - - -N10->N2 - - - - - - - 2.42s - - - - -N10->N9 - - - - - - - 0.71s - - - - -N10->N12 - - - - - - - 0.02s - - - - -N17 - - -runtime -makeslice -0.02s (0.1%) -of 1.09s (5.51%) - - - - -N10->N17 - - - - - - - 0.64s - - - - -N33 - - -github -com/prometheus/prometheus/pkg/textparse -(*lexer) -cur -0.60s (3.03%) - - - - -N11->N33 - - - - - - - 0.60s - (inline) - - - - -N12->N4 - - - - - - - 0.95s - - - - -N13 - - -compress/flate -(*decompressor) -huffmanBlock -0.44s (2.22%) -of 1.97s (9.96%) - - - - -N18 - - -compress/flate -(*decompressor) -moreBits -0.42s (2.12%) -of 0.80s (4.04%) - - - - -N13->N18 - - - - - - - 0.20s - - - - -N19 - - -compress/flate -(*decompressor) -huffSym -0.48s (2.43%) -of 1.08s (5.46%) - - - - -N13->N19 - - - - - - - 1.03s - - - - -N66 - - -compress/flate -(*dictDecoder) -tryWriteCopy -0.13s (0.66%) -of 0.22s (1.11%) - - - - -N13->N66 - - - - - - - 0.22s - (inline) - - - - -N14->N2 - - - - - - - 2.84s - - - - -N14->N9 - - - - - - - 1.07s - - - - -N15->N7 - - - - - - - 2.41s - - - - -N61 - - -unicode/utf8 -Valid -0.19s (0.96%) - - - - -N15->N61 - - - - - - - 0.19s - - - - -N16 - - -runtime -futex -0.79s (3.99%) - - - - -N17->N4 - - - - - - - 1.07s - - - - -N42 - - -bytes -(*Reader) -ReadByte -0.38s (1.92%) - - - - -N18->N42 - - - - - - - 0.38s - - - - -N19->N18 - - - - - - - 0.60s - - - - -N20 - - -bytes -(*Buffer) -ReadFrom -0 of 2.63s (13.30%) - - - - -N20->N17 - - - - - - - 0.31s - - - - -N32 - - -runtime -memmove -0.31s (1.57%) - - - - -N20->N32 - - - - - - - 0.03s - - - - -N77 - - -compress/flate -(*decompressor) -Read -0 of 2.16s (10.92%) - - - - -N20->N77 - - - - - - - 2.16s - - - - -N22 - - -runtime -schedule -0.01s (0.051%) -of 0.71s (3.59%) - - - - -N22->N55 - - - - - - - 0.02s - - - - -N68 - - -runtime -findrunnable -0.02s (0.1%) -of 0.41s (2.07%) - - - - -N22->N68 - - - - - - - 0.41s - - - - -N24 - - -runtime -scanobject -0.31s (1.57%) -of 0.62s (3.13%) - - - - -N24->N44 - - - - - - - 0.13s - - - - -N70 - - -runtime -greyobject -0.08s (0.4%) -of 0.12s (0.61%) - - - - -N24->N70 - - - - - - - 0.08s - - - - -N25->N4 - - - - - - - 0.60s - - - - -N25->N32 - - - - - - - 0.14s - - - - -N26->N12 - - - - - - - 0.18s - - - - -N26->N57 - - - - - - - 0.11s - - - - -N59 - - -bytes -(*Buffer) -String -0.01s (0.051%) -of 0.19s (0.96%) - - - - -N26->N59 - - - - - - - 0.08s - (inline) - - - - -N69 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/expfmt -(*TextParser) -readTokenAsLabelName -0.06s (0.3%) -of 0.18s (0.91%) - - - - -N26->N69 - - - - - - - 0.18s - - - - -N27->N8 - - - - - - - 2.89s - - - - -N56 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/expfmt -extractUntyped -0.03s (0.15%) -of 0.27s (1.37%) - - - - -N27->N56 - - - - - - - 0.27s - - - - -N28 - - -runtime -gcBgMarkWorker -0.03s (0.15%) -of 1.20s (6.07%) - - - - -N28->N6 - - - - - - - 1.14s - - - - -N29->N12 - - - - - - - 0.08s - - - - -N29->N41 - - - - - - - 0.08s - - - - -N29->N57 - - - - - - - 0.04s - - - - -N67 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/model -LabelsToSignature -0 of 0.15s (0.76%) - - - - -N29->N67 - - - - - - - 0.15s - - - - -N78 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/expfmt -(*TextParser) -readTokenUntilWhitespace -0.06s (0.3%) -of 0.10s (0.51%) - - - - -N29->N78 - - - - - - - 0.09s - - - - -N30->N24 - - - - - - - 0.53s - - - - -N74 - - -runtime -markroot -0 of 0.29s (1.47%) - - - - -N30->N74 - - - - - - - 0.17s - - - - -N31 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/expfmt -(*TextParser) -readTokenAsMetricName -0.10s (0.51%) -of 0.54s (2.73%) - - - - -N31->N23 - - - - - - - 0.22s - - - - -N43 - - -bytes -(*Buffer) -WriteByte -0.15s (0.76%) -of 0.21s (1.06%) - - - - -N31->N43 - - - - - - - 0.13s - - - - -N34 - - -runtime -stopm -0 of 0.45s (2.28%) - - - - -N34->N30 - - - - - - - 0.02s - - - - -N34->N47 - - - - - - - 0.02s - - - - -N52 - - -runtime -lock -0.07s (0.35%) -of 0.19s (0.96%) - - - - -N34->N52 - - - - - - - 0.11s - - - - -N53 - - -runtime -futexsleep -0.01s (0.051%) -of 0.34s (1.72%) - - - - -N34->N53 - - - - - - - 0.20s - - - - -N58 - - -runtime -unlock -0.04s (0.2%) -of 0.14s (0.71%) - - - - -N34->N58 - - - - - - - 0.08s - - - - -N35->N12 - - - - - - - 0.13s - - - - -N35->N31 - - - - - - - 0.46s - - - - -N40 - - -github -com/prometheus/prometheus/vendor/github -com/prometheus/common/expfmt -(*TextParser) -setOrCreateCurrentMF -0.04s (0.2%) -of 0.28s (1.42%) - - - - -N35->N40 - - - - - - - 0.21s - - - - -N36->N12 - - - - - - - 0.12s - - - - -N36->N23 - - - - - - - 0.05s - - - - -N36->N43 - - - - - - - 0.03s - - - - -N36->N59 - - - - - - - 0.06s - (inline) - - - - -N37->N12 - - - - - - - 0.06s - - - - -N37->N17 - - - - - - - 0.07s - - - - -N54 - - -io/ioutil -readAll -0.01s (0.051%) -of 2.72s (13.75%) - - - - -N37->N54 - - - - - - - 2.72s - - - - -N39 - - -runtime -mcall -0 of 0.63s (3.19%) - - - - -N39->N22 - - - - - - - 0.57s - - - - -N80 - - -runtime -goschedImpl -0 of 0.19s (0.96%) - - - - -N39->N80 - - - - - - - 0.05s - - - - -N40->N12 - - - - - - - 0.02s - - - - -N46 - - -runtime -mapassign_faststr -0.05s (0.25%) -of 0.23s (1.16%) - - - - -N40->N46 - - - - - - - 0.06s - - - - -N40->N59 - - - - - - - 0.03s - (inline) - - - - -N76 - - -runtime -mapaccess1_faststr -0.09s (0.46%) -of 0.12s (0.61%) - - - - -N40->N76 - - - - - - - 0.11s - - - - -N48 - - -strconv -atof64 -0.12s (0.61%) -of 0.51s (2.58%) - - - - -N41->N48 - - - - - - - 0.51s - - - - -N45 - - -runtime -(*mheap) -alloc -0.01s (0.051%) -of 0.83s (4.20%) - - - - -N45->N21 - - - - - - - 0.69s - - - - -N71 - - -runtime -sweepone -0.10s (0.51%) -of 0.20s (1.01%) - - - - -N45->N71 - - - - - - - 0.03s - - - - -N46->N12 - - - - - - - 0.12s - - - - -N65 - - -runtime -futexwakeup -0 of 0.46s (2.33%) - - - - -N47->N65 - - - - - - - 0.36s - - - - -N63 - - -strconv -readFloat -0.18s (0.91%) - - - - -N48->N63 - - - - - - - 0.18s - - - - -N49 - - -compress/flate -(*decompressor) -nextBlock -0 of 2.13s (10.77%) - - - - -N49->N13 - - - - - - - 1.96s - - - - -N49->N17 - - - - - - - 0.03s - - - - -N50->N45 - - - - - - - 0.77s - - - - -N50->N52 - - - - - - - 0.04s - - - - -N50->N58 - - - - - - - 0.02s - - - - -N52->N53 - - - - - - - 0.08s - - - - -N53->N16 - - - - - - - 0.33s - - - - -N54->N12 - - - - - - - 0.06s - - - - -N54->N20 - - - - - - - 2.63s - - - - -N55->N6 - - - - - - - 0.03s - - - - -N55->N44 - - - - - - - 0.02s - - - - -N56->N12 - - - - - - - 0.06s - - - - -N56->N17 - - - - - - - 0.02s - - - - -N56->N46 - - - - - - - 0.12s - - - - -N57->N4 - - - - - - - 0.15s - - - - -N58->N65 - - - - - - - 0.10s - - - - -N59->N25 - - - - - - - 0.18s - - - - -N60->N4 - - - - - - - 0.49s - - - - -N62->N12 - - - - - - - 0.02s - - - - -N62->N31 - - - - - - - 0.08s - - - - -N62->N40 - - - - - - - 0.07s - - - - -N65->N16 - - - - - - - 0.46s - - - - -N66->N32 - - - - - - - 0.09s - - - - -N67->N17 - - - - - - - 0.02s - - - - -N67->N60 - - - - - - - 0.03s - - - - -N68->N34 - - - - - - - 0.35s - - - - -N69->N23 - - - - - - - 0.07s - - - - -N69->N43 - - - - - - - 0.02s - - - - -N72 - - -runtime -scanblock -0.09s (0.46%) -of 0.15s (0.76%) - - - - -N72->N44 - - - - - - - 0.02s - - - - -N72->N70 - - - - - - - 0.04s - - - - -N73->N24 - - - - - - - 0.09s - - - - -N73->N74 - - - - - - - 0.12s - - - - -N74->N72 - - - - - - - 0.15s - - - - -N77->N32 - - - - - - - 0.02s - - - - -N77->N49 - - - - - - - 2.13s - - - - -N78->N23 - - - - - - - 0.02s - - - - -N78->N43 - - - - - - - 0.02s - - - - -N79->N6 - - - - - - - 0.94s - - - - -N80->N22 - - - - - - - 0.14s - - - - -N80->N52 - - - - - - - 0.03s - - - - -