Merge pull request #14233 from kubernetes/revert-14202-prometheus

Godeps/Godeps.json

@@ -455,22 +455,29 @@
 			"Rev": "ca53cad383cad2479bbba7f7a1a05797ec1386e4"
 		},
 		{
-			"ImportPath": "github.com/prometheus/client_golang/prometheus",
-			"Comment": "0.7.0-39-g3b78d7a",
-			"Rev": "3b78d7a77f51ccbc364d4bc170920153022cfd08"
+			"ImportPath": "github.com/prometheus/client_golang/extraction",
+			"Comment": "0.4.0-1-g692492e",
+			"Rev": "692492e54b553a81013254cc1fba4b6dd76fad30"
 		},
 		{
-			"ImportPath": "github.com/prometheus/client_model/go",
-			"Comment": "model-0.0.2-12-gfa8ad6f",
-			"Rev": "fa8ad6fec33561be4280a8f0514318c79d7f6cb6"
+			"ImportPath": "github.com/prometheus/client_golang/model",
+			"Comment": "0.4.0-1-g692492e",
+			"Rev": "692492e54b553a81013254cc1fba4b6dd76fad30"
+		},
+		{
+			"ImportPath": "github.com/prometheus/client_golang/prometheus",
+			"Comment": "0.4.0-1-g692492e",
+			"Rev": "692492e54b553a81013254cc1fba4b6dd76fad30"
 		},
 		{
-			"ImportPath": "github.com/prometheus/common/expfmt",
-			"Rev": "53cc5b7aea4df4e69c1b9d71fca97d43b416a3ad"
+			"ImportPath": "github.com/prometheus/client_golang/text",
+			"Comment": "0.4.0-1-g692492e",
+			"Rev": "692492e54b553a81013254cc1fba4b6dd76fad30"
 		},
 		{
-			"ImportPath": "github.com/prometheus/common/model",
-			"Rev": "53cc5b7aea4df4e69c1b9d71fca97d43b416a3ad"
+			"ImportPath": "github.com/prometheus/client_model/go",
+			"Comment": "model-0.0.2-12-gfa8ad6f",
+			"Rev": "fa8ad6fec33561be4280a8f0514318c79d7f6cb6"
 		},
 		{
 			"ImportPath": "github.com/prometheus/procfs",

Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/discriminator.go

+// Copyright 2013 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 extraction
+
+import (
+	"errors"
+	"fmt"
+	"mime"
+	"net/http"
+)
+
+// ProcessorForRequestHeader interprets a HTTP request header to determine
+// what Processor should be used for the given input.  If no acceptable
+// Processor can be found, an error is returned.
+func ProcessorForRequestHeader(header http.Header) (Processor, error) {
+	if header == nil {
+		return nil, errors.New("received illegal and nil header")
+	}
+
+	mediatype, params, err := mime.ParseMediaType(header.Get("Content-Type"))
+	if err != nil {
+		return nil, fmt.Errorf("invalid Content-Type header %q: %s", header.Get("Content-Type"), err)
+	}
+	switch mediatype {
+	case "application/vnd.google.protobuf":
+		if params["proto"] != "io.prometheus.client.MetricFamily" {
+			return nil, fmt.Errorf("unrecognized protocol message %s", params["proto"])
+		}
+		if params["encoding"] != "delimited" {
+			return nil, fmt.Errorf("unsupported encoding %s", params["encoding"])
+		}
+		return MetricFamilyProcessor, nil
+	case "text/plain":
+		switch params["version"] {
+		case "0.0.4":
+			return Processor004, nil
+		case "":
+			// Fallback: most recent version.
+			return Processor004, nil
+		default:
+			return nil, fmt.Errorf("unrecognized API version %s", params["version"])
+		}
+	case "application/json":
+		var prometheusAPIVersion string
+
+		if params["schema"] == "prometheus/telemetry" && params["version"] != "" {
+			prometheusAPIVersion = params["version"]
+		} else {
+			prometheusAPIVersion = header.Get("X-Prometheus-API-Version")
+		}
+
+		switch prometheusAPIVersion {
+		case "0.0.2":
+			return Processor002, nil
+		case "0.0.1":
+			return Processor001, nil
+		default:
+			return nil, fmt.Errorf("unrecognized API version %s", prometheusAPIVersion)
+		}
+	default:
+		return nil, fmt.Errorf("unsupported media type %q, expected %q", mediatype, "application/json")
+	}
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/discriminator_test.go

+// Copyright 2013 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 extraction
+
+import (
+	"errors"
+	"net/http"
+	"testing"
+)
+
+func testDiscriminatorHTTPHeader(t testing.TB) {
+	var scenarios = []struct {
+		input  map[string]string
+		output Processor
+		err    error
+	}{
+		{
+			output: nil,
+			err:    errors.New("received illegal and nil header"),
+		},
+		{
+			input:  map[string]string{"Content-Type": "application/json", "X-Prometheus-API-Version": "0.0.0"},
+			output: nil,
+			err:    errors.New("unrecognized API version 0.0.0"),
+		},
+		{
+			input:  map[string]string{"Content-Type": "application/json", "X-Prometheus-API-Version": "0.0.1"},
+			output: Processor001,
+			err:    nil,
+		},
+		{
+			input:  map[string]string{"Content-Type": `application/json; schema="prometheus/telemetry"; version=0.0.0`},
+			output: nil,
+			err:    errors.New("unrecognized API version 0.0.0"),
+		},
+		{
+			input:  map[string]string{"Content-Type": `application/json; schema="prometheus/telemetry"; version=0.0.1`},
+			output: Processor001,
+			err:    nil,
+		},
+		{
+			input:  map[string]string{"Content-Type": `application/json; schema="prometheus/telemetry"; version=0.0.2`},
+			output: Processor002,
+			err:    nil,
+		},
+		{
+			input:  map[string]string{"Content-Type": `application/vnd.google.protobuf; proto="io.prometheus.client.MetricFamily"; encoding="delimited"`},
+			output: MetricFamilyProcessor,
+			err:    nil,
+		},
+		{
+			input:  map[string]string{"Content-Type": `application/vnd.google.protobuf; proto="illegal"; encoding="delimited"`},
+			output: nil,
+			err:    errors.New("unrecognized protocol message illegal"),
+		},
+		{
+			input:  map[string]string{"Content-Type": `application/vnd.google.protobuf; proto="io.prometheus.client.MetricFamily"; encoding="illegal"`},
+			output: nil,
+			err:    errors.New("unsupported encoding illegal"),
+		},
+		{
+			input:  map[string]string{"Content-Type": `text/plain; version=0.0.4`},
+			output: Processor004,
+			err:    nil,
+		},
+		{
+			input:  map[string]string{"Content-Type": `text/plain`},
+			output: Processor004,
+			err:    nil,
+		},
+		{
+			input:  map[string]string{"Content-Type": `text/plain; version=0.0.3`},
+			output: nil,
+			err:    errors.New("unrecognized API version 0.0.3"),
+		},
+	}
+
+	for i, scenario := range scenarios {
+		var header http.Header
+
+		if len(scenario.input) > 0 {
+			header = http.Header{}
+		}
+
+		for key, value := range scenario.input {
+			header.Add(key, value)
+		}
+
+		actual, err := ProcessorForRequestHeader(header)
+
+		if scenario.err != err {
+			if scenario.err != nil && err != nil {
+				if scenario.err.Error() != err.Error() {
+					t.Errorf("%d. expected %s, got %s", i, scenario.err, err)
+				}
+			} else if scenario.err != nil || err != nil {
+				t.Errorf("%d. expected %s, got %s", i, scenario.err, err)
+			}
+		}
+
+		if scenario.output != actual {
+			t.Errorf("%d. expected %s, got %s", i, scenario.output, actual)
+		}
+	}
+}
+
+func TestDiscriminatorHTTPHeader(t *testing.T) {
+	testDiscriminatorHTTPHeader(t)
+}
+
+func BenchmarkDiscriminatorHTTPHeader(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		testDiscriminatorHTTPHeader(b)
+	}
+}

Godeps/_workspace/src/github.com/prometheus/common/expfmt/fuzz.go → Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/extraction.go

-// Copyright 2014 The Prometheus Authors
+// Copyright 2013 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
@@ -11,26 +11,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Build only when actually fuzzing
-// +build gofuzz
-
-package expfmt
-
-import "bytes"
-
-// Fuzz text metric parser with with github.com/dvyukov/go-fuzz:
-//
-//     go-fuzz-build github.com/prometheus/client_golang/text
-//     go-fuzz -bin text-fuzz.zip -workdir fuzz
-//
-// Further input samples should go in the folder fuzz/corpus.
-func Fuzz(in []byte) int {
-	parser := TextParser{}
-	_, err := parser.TextToMetricFamilies(bytes.NewReader(in))
-
-	if err != nil {
-		return 0
-	}
-
-	return 1
-}
+// Package extraction decodes Prometheus clients' data streams for consumers.
+package extraction

Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/fixtures/test0_0_1-0_0_2.json

+[
+  {
+    "baseLabels": {
+      "__name__": "rpc_calls_total",
+      "job": "batch_job"
+    },
+    "docstring": "RPC calls.",
+    "metric": {
+      "type": "counter",
+      "value": [
+        {
+          "labels": {
+            "service": "zed"
+          },
+          "value": 25
+        },
+        {
+          "labels": {
+            "service": "bar"
+          },
+          "value": 25
+        },
+        {
+          "labels": {
+            "service": "foo"
+          },
+          "value": 25
+        }
+      ]
+    }
+  },
+  {
+    "baseLabels": {
+      "__name__": "rpc_latency_microseconds"
+    },
+      "docstring": "RPC latency.",
+      "metric": {
+        "type": "histogram",
+        "value": [
+          {
+            "labels": {
+              "service": "foo"
+            },
+            "value": {
+              "0.010000": 15.890724674774395,
+              "0.050000": 15.890724674774395,
+              "0.500000": 84.63044031436561,
+              "0.900000": 160.21100853053224,
+              "0.990000": 172.49828748957728
+            }
+          },
+          {
+            "labels": {
+              "service": "zed"
+            },
+            "value": {
+              "0.010000": 0.0459814091918713,
+              "0.050000": 0.0459814091918713,
+              "0.500000": 0.6120456642749681,
+              "0.900000": 1.355915069887731,
+              "0.990000": 1.772733213161236
+            }
+          },
+          {
+            "labels": {
+              "service": "bar"
+            },
+            "value": {
+              "0.010000": 78.48563317257356,
+              "0.050000": 78.48563317257356,
+              "0.500000": 97.31798360385088,
+              "0.900000": 109.89202084295582,
+              "0.990000": 109.99626121011262
+            }
+          }
+        ]
+      }
+  }
+]

Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/metricfamilyprocessor.go

+// Copyright 2013 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 extraction
+
+import (
+	"fmt"
+	"io"
+	"math"
+
+	dto "github.com/prometheus/client_model/go"
+
+	"github.com/matttproud/golang_protobuf_extensions/pbutil"
+
+	"github.com/prometheus/client_golang/model"
+)
+
+type metricFamilyProcessor struct{}
+
+// MetricFamilyProcessor decodes varint encoded record length-delimited streams
+// of io.prometheus.client.MetricFamily.
+//
+// See http://godoc.org/github.com/matttproud/golang_protobuf_extensions/ext for
+// more details.
+var MetricFamilyProcessor = &metricFamilyProcessor{}
+
+func (m *metricFamilyProcessor) ProcessSingle(i io.Reader, out Ingester, o *ProcessOptions) error {
+	family := &dto.MetricFamily{}
+
+	for {
+		family.Reset()
+
+		if _, err := pbutil.ReadDelimited(i, family); err != nil {
+			if err == io.EOF {
+				return nil
+			}
+			return err
+		}
+		if err := extractMetricFamily(out, o, family); err != nil {
+			return err
+		}
+	}
+}
+
+func extractMetricFamily(out Ingester, o *ProcessOptions, family *dto.MetricFamily) error {
+	switch family.GetType() {
+	case dto.MetricType_COUNTER:
+		if err := extractCounter(out, o, family); err != nil {
+			return err
+		}
+	case dto.MetricType_GAUGE:
+		if err := extractGauge(out, o, family); err != nil {
+			return err
+		}
+	case dto.MetricType_SUMMARY:
+		if err := extractSummary(out, o, family); err != nil {
+			return err
+		}
+	case dto.MetricType_UNTYPED:
+		if err := extractUntyped(out, o, family); err != nil {
+			return err
+		}
+	case dto.MetricType_HISTOGRAM:
+		if err := extractHistogram(out, o, family); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func extractCounter(out Ingester, o *ProcessOptions, f *dto.MetricFamily) error {
+	samples := make(model.Samples, 0, len(f.Metric))
+
+	for _, m := range f.Metric {
+		if m.Counter == nil {
+			continue
+		}
+
+		sample := &model.Sample{
+			Metric: model.Metric{},
+			Value:  model.SampleValue(m.Counter.GetValue()),
+		}
+		samples = append(samples, sample)
+
+		if m.TimestampMs != nil {
+			sample.Timestamp = model.TimestampFromUnixNano(*m.TimestampMs * 1000000)
+		} else {
+			sample.Timestamp = o.Timestamp
+		}
+
+		metric := sample.Metric
+		for _, p := range m.Label {
+			metric[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())
+		}
+		metric[model.MetricNameLabel] = model.LabelValue(f.GetName())
+	}
+
+	return out.Ingest(samples)
+}
+
+func extractGauge(out Ingester, o *ProcessOptions, f *dto.MetricFamily) error {
+	samples := make(model.Samples, 0, len(f.Metric))
+
+	for _, m := range f.Metric {
+		if m.Gauge == nil {
+			continue
+		}
+
+		sample := &model.Sample{
+			Metric: model.Metric{},
+			Value:  model.SampleValue(m.Gauge.GetValue()),
+		}
+		samples = append(samples, sample)
+
+		if m.TimestampMs != nil {
+			sample.Timestamp = model.TimestampFromUnixNano(*m.TimestampMs * 1000000)
+		} else {
+			sample.Timestamp = o.Timestamp
+		}
+
+		metric := sample.Metric
+		for _, p := range m.Label {
+			metric[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())
+		}
+		metric[model.MetricNameLabel] = model.LabelValue(f.GetName())
+	}
+
+	return out.Ingest(samples)
+}
+
+func extractSummary(out Ingester, o *ProcessOptions, f *dto.MetricFamily) error {
+	samples := make(model.Samples, 0, len(f.Metric))
+
+	for _, m := range f.Metric {
+		if m.Summary == nil {
+			continue
+		}
+
+		timestamp := o.Timestamp
+		if m.TimestampMs != nil {
+			timestamp = model.TimestampFromUnixNano(*m.TimestampMs * 1000000)
+		}
+
+		for _, q := range m.Summary.Quantile {
+			sample := &model.Sample{
+				Metric:    model.Metric{},
+				Value:     model.SampleValue(q.GetValue()),
+				Timestamp: timestamp,
+			}
+			samples = append(samples, sample)
+
+			metric := sample.Metric
+			for _, p := range m.Label {
+				metric[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())
+			}
+			// BUG(matt): Update other names to "quantile".
+			metric[model.LabelName(model.QuantileLabel)] = model.LabelValue(fmt.Sprint(q.GetQuantile()))
+			metric[model.MetricNameLabel] = model.LabelValue(f.GetName())
+		}
+
+		if m.Summary.SampleSum != nil {
+			sum := &model.Sample{
+				Metric:    model.Metric{},
+				Value:     model.SampleValue(m.Summary.GetSampleSum()),
+				Timestamp: timestamp,
+			}
+			samples = append(samples, sum)
+
+			metric := sum.Metric
+			for _, p := range m.Label {
+				metric[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())
+			}
+			metric[model.MetricNameLabel] = model.LabelValue(f.GetName() + "_sum")
+		}
+
+		if m.Summary.SampleCount != nil {
+			count := &model.Sample{
+				Metric:    model.Metric{},
+				Value:     model.SampleValue(m.Summary.GetSampleCount()),
+				Timestamp: timestamp,
+			}
+			samples = append(samples, count)
+
+			metric := count.Metric
+			for _, p := range m.Label {
+				metric[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())
+			}
+			metric[model.MetricNameLabel] = model.LabelValue(f.GetName() + "_count")
+		}
+	}
+
+	return out.Ingest(samples)
+}
+
+func extractUntyped(out Ingester, o *ProcessOptions, f *dto.MetricFamily) error {
+	samples := make(model.Samples, 0, len(f.Metric))
+
+	for _, m := range f.Metric {
+		if m.Untyped == nil {
+			continue
+		}
+
+		sample := &model.Sample{
+			Metric: model.Metric{},
+			Value:  model.SampleValue(m.Untyped.GetValue()),
+		}
+		samples = append(samples, sample)
+
+		if m.TimestampMs != nil {
+			sample.Timestamp = model.TimestampFromUnixNano(*m.TimestampMs * 1000000)
+		} else {
+			sample.Timestamp = o.Timestamp
+		}
+
+		metric := sample.Metric
+		for _, p := range m.Label {
+			metric[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())
+		}
+		metric[model.MetricNameLabel] = model.LabelValue(f.GetName())
+	}
+
+	return out.Ingest(samples)
+}
+
+func extractHistogram(out Ingester, o *ProcessOptions, f *dto.MetricFamily) error {
+	samples := make(model.Samples, 0, len(f.Metric))
+
+	for _, m := range f.Metric {
+		if m.Histogram == nil {
+			continue
+		}
+
+		timestamp := o.Timestamp
+		if m.TimestampMs != nil {
+			timestamp = model.TimestampFromUnixNano(*m.TimestampMs * 1000000)
+		}
+
+		infSeen := false
+
+		for _, q := range m.Histogram.Bucket {
+			sample := &model.Sample{
+				Metric:    model.Metric{},
+				Value:     model.SampleValue(q.GetCumulativeCount()),
+				Timestamp: timestamp,
+			}
+			samples = append(samples, sample)
+
+			metric := sample.Metric
+			for _, p := range m.Label {
+				metric[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())
+			}
+			metric[model.LabelName(model.BucketLabel)] = model.LabelValue(fmt.Sprint(q.GetUpperBound()))
+			metric[model.MetricNameLabel] = model.LabelValue(f.GetName() + "_bucket")
+
+			if math.IsInf(q.GetUpperBound(), +1) {
+				infSeen = true
+			}
+		}
+
+		if m.Histogram.SampleSum != nil {
+			sum := &model.Sample{
+				Metric:    model.Metric{},
+				Value:     model.SampleValue(m.Histogram.GetSampleSum()),
+				Timestamp: timestamp,
+			}
+			samples = append(samples, sum)
+
+			metric := sum.Metric
+			for _, p := range m.Label {
+				metric[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())
+			}
+			metric[model.MetricNameLabel] = model.LabelValue(f.GetName() + "_sum")
+		}
+
+		if m.Histogram.SampleCount != nil {
+			count := &model.Sample{
+				Metric:    model.Metric{},
+				Value:     model.SampleValue(m.Histogram.GetSampleCount()),
+				Timestamp: timestamp,
+			}
+			samples = append(samples, count)
+
+			metric := count.Metric
+			for _, p := range m.Label {
+				metric[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())
+			}
+			metric[model.MetricNameLabel] = model.LabelValue(f.GetName() + "_count")
+
+			if !infSeen {
+				infBucket := &model.Sample{
+					Metric:    model.Metric{},
+					Value:     count.Value,
+					Timestamp: timestamp,
+				}
+				samples = append(samples, infBucket)
+
+				metric := infBucket.Metric
+				for _, p := range m.Label {
+					metric[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue())
+				}
+				metric[model.LabelName(model.BucketLabel)] = model.LabelValue("+Inf")
+				metric[model.MetricNameLabel] = model.LabelValue(f.GetName() + "_bucket")
+			}
+		}
+	}
+
+	return out.Ingest(samples)
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/metricfamilyprocessor_test.go

+// Copyright 2013 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 extraction
+
+import (
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/prometheus/client_golang/model"
+)
+
+var testTime = model.Now()
+
+type metricFamilyProcessorScenario struct {
+	in               string
+	expected, actual []model.Samples
+}
+
+func (s *metricFamilyProcessorScenario) Ingest(samples model.Samples) error {
+	s.actual = append(s.actual, samples)
+	return nil
+}
+
+func (s *metricFamilyProcessorScenario) test(t *testing.T, set int) {
+	i := strings.NewReader(s.in)
+
+	o := &ProcessOptions{
+		Timestamp: testTime,
+	}
+
+	err := MetricFamilyProcessor.ProcessSingle(i, s, o)
+	if err != nil {
+		t.Fatalf("%d. got error: %s", set, err)
+	}
+
+	if len(s.expected) != len(s.actual) {
+		t.Fatalf("%d. expected length %d, got %d", set, len(s.expected), len(s.actual))
+	}
+
+	for i, expected := range s.expected {
+		sort.Sort(s.actual[i])
+		sort.Sort(expected)
+
+		if !expected.Equal(s.actual[i]) {
+			t.Errorf("%d.%d. expected %s, got %s", set, i, expected, s.actual[i])
+		}
+	}
+}
+
+func TestMetricFamilyProcessor(t *testing.T) {
+	scenarios := []metricFamilyProcessorScenario{
+		{
+			in: "",
+		},
+		{
+			in: "\x8f\x01\n\rrequest_count\x12\x12Number of requests\x18\x00\"0\n#\n\x0fsome_label_name\x12\x10some_label_value\x1a\t\t\x00\x00\x00\x00\x00\x00E\xc0\"6\n)\n\x12another_label_name\x12\x13another_label_value\x1a\t\t\x00\x00\x00\x00\x00\x00U@",
+			expected: []model.Samples{
+				model.Samples{
+					&model.Sample{
+						Metric:    model.Metric{model.MetricNameLabel: "request_count", "some_label_name": "some_label_value"},
+						Value:     -42,
+						Timestamp: testTime,
+					},
+					&model.Sample{
+						Metric:    model.Metric{model.MetricNameLabel: "request_count", "another_label_name": "another_label_value"},
+						Value:     84,
+						Timestamp: testTime,
+					},
+				},
+			},
+		},
+		{
+			in: "\xb9\x01\n\rrequest_count\x12\x12Number of requests\x18\x02\"O\n#\n\x0fsome_label_name\x12\x10some_label_value\"(\x1a\x12\t\xaeG\xe1z\x14\xae\xef?\x11\x00\x00\x00\x00\x00\x00E\xc0\x1a\x12\t+\x87\x16\xd9\xce\xf7\xef?\x11\x00\x00\x00\x00\x00\x00U\xc0\"A\n)\n\x12another_label_name\x12\x13another_label_value\"\x14\x1a\x12\t\x00\x00\x00\x00\x00\x00\xe0?\x11\x00\x00\x00\x00\x00\x00$@",
+			expected: []model.Samples{
+				model.Samples{
+					&model.Sample{
+						Metric:    model.Metric{model.MetricNameLabel: "request_count", "some_label_name": "some_label_value", "quantile": "0.99"},
+						Value:     -42,
+						Timestamp: testTime,
+					},
+					&model.Sample{
+						Metric:    model.Metric{model.MetricNameLabel: "request_count", "some_label_name": "some_label_value", "quantile": "0.999"},
+						Value:     -84,
+						Timestamp: testTime,
+					},
+					&model.Sample{
+						Metric:    model.Metric{model.MetricNameLabel: "request_count", "another_label_name": "another_label_value", "quantile": "0.5"},
+						Value:     10,
+						Timestamp: testTime,
+					},
+				},
+			},
+		},
+		{
+			in: "\x8d\x01\n\x1drequest_duration_microseconds\x12\x15The response latency.\x18\x04\"S:Q\b\x85\x15\x11\xcd\xcc\xccL\x8f\xcb:A\x1a\v\b{\x11\x00\x00\x00\x00\x00\x00Y@\x1a\f\b\x9c\x03\x11\x00\x00\x00\x00\x00\x00^@\x1a\f\b\xd0\x04\x11\x00\x00\x00\x00\x00\x00b@\x1a\f\b\xf4\v\x11\x9a\x99\x99\x99\x99\x99e@\x1a\f\b\x85\x15\x11\x00\x00\x00\x00\x00\x00\xf0\u007f",
+			expected: []model.Samples{
+				model.Samples{
+					&model.Sample{
+						Metric:    model.Metric{model.MetricNameLabel: "request_duration_microseconds_bucket", "le": "100"},
+						Value:     123,
+						Timestamp: testTime,
+					},
+					&model.Sample{
+						Metric:    model.Metric{model.MetricNameLabel: "request_duration_microseconds_bucket", "le": "120"},
+						Value:     412,
+						Timestamp: testTime,
+					},
+					&model.Sample{
+						Metric:    model.Metric{model.MetricNameLabel: "request_duration_microseconds_bucket", "le": "144"},
+						Value:     592,
+						Timestamp: testTime,
+					},
+					&model.Sample{
+						Metric:    model.Metric{model.MetricNameLabel: "request_duration_microseconds_bucket", "le": "172.8"},
+						Value:     1524,
+						Timestamp: testTime,
+					},
+					&model.Sample{
+						Metric:    model.Metric{model.MetricNameLabel: "request_duration_microseconds_bucket", "le": "+Inf"},
+						Value:     2693,
+						Timestamp: testTime,
+					},
+					&model.Sample{
+						Metric:    model.Metric{model.MetricNameLabel: "request_duration_microseconds_sum"},
+						Value:     1756047.3,
+						Timestamp: testTime,
+					},
+					&model.Sample{
+						Metric:    model.Metric{model.MetricNameLabel: "request_duration_microseconds_count"},
+						Value:     2693,
+						Timestamp: testTime,
+					},
+				},
+			},
+		},
+	}
+
+	for i, scenario := range scenarios {
+		scenario.test(t, i)
+	}
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/processor.go

+// Copyright 2013 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 extraction
+
+import (
+	"io"
+	"time"
+
+	"github.com/prometheus/client_golang/model"
+)
+
+// ProcessOptions dictates how the interpreted stream should be rendered for
+// consumption.
+type ProcessOptions struct {
+	// Timestamp is added to each value from the stream that has no explicit
+	// timestamp set.
+	Timestamp model.Timestamp
+}
+
+// Ingester consumes result streams in whatever way is desired by the user.
+type Ingester interface {
+	Ingest(model.Samples) error
+}
+
+// Processor is responsible for decoding the actual message responses from
+// stream into a format that can be consumed with the end result written
+// to the results channel.
+type Processor interface {
+	// ProcessSingle treats the input as a single self-contained message body and
+	// transforms it accordingly.  It has no support for streaming.
+	ProcessSingle(in io.Reader, out Ingester, o *ProcessOptions) error
+}
+
+// Helper function to convert map[string]string into LabelSet.
+//
+// NOTE: This should be deleted when support for go 1.0.3 is removed; 1.1 is
+//       smart enough to unmarshal JSON objects into LabelSet directly.
+func labelSet(labels map[string]string) model.LabelSet {
+	labelset := make(model.LabelSet, len(labels))
+
+	for k, v := range labels {
+		labelset[model.LabelName(k)] = model.LabelValue(v)
+	}
+
+	return labelset
+}
+
+// A basic interface only useful in testing contexts for dispensing the time
+// in a controlled manner.
+type instantProvider interface {
+	// The current instant.
+	Now() time.Time
+}
+
+// Clock is a simple means for fluently wrapping around standard Go timekeeping
+// mechanisms to enhance testability without compromising code readability.
+//
+// It is sufficient for use on bare initialization.  A provider should be
+// set only for test contexts.  When not provided, it emits the current
+// system time.
+type clock struct {
+	// The underlying means through which time is provided, if supplied.
+	Provider instantProvider
+}
+
+// Emit the current instant.
+func (t *clock) Now() time.Time {
+	if t.Provider == nil {
+		return time.Now()
+	}
+
+	return t.Provider.Now()
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/processor0_0_1.go

+// Copyright 2013 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 extraction
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+
+	"github.com/prometheus/client_golang/model"
+)
+
+const (
+	baseLabels001 = "baseLabels"
+	counter001    = "counter"
+	docstring001  = "docstring"
+	gauge001      = "gauge"
+	histogram001  = "histogram"
+	labels001     = "labels"
+	metric001     = "metric"
+	type001       = "type"
+	value001      = "value"
+	percentile001 = "percentile"
+)
+
+// Processor001 is responsible for decoding payloads from protocol version
+// 0.0.1.
+var Processor001 = &processor001{}
+
+// processor001 is responsible for handling API version 0.0.1.
+type processor001 struct{}
+
+// entity001 represents a the JSON structure that 0.0.1 uses.
+type entity001 []struct {
+	BaseLabels map[string]string `json:"baseLabels"`
+	Docstring  string            `json:"docstring"`
+	Metric     struct {
+		MetricType string `json:"type"`
+		Value      []struct {
+			Labels map[string]string `json:"labels"`
+			Value  interface{}       `json:"value"`
+		} `json:"value"`
+	} `json:"metric"`
+}
+
+func (p *processor001) ProcessSingle(in io.Reader, out Ingester, o *ProcessOptions) error {
+	// TODO(matt): Replace with plain-jane JSON unmarshalling.
+	buffer, err := ioutil.ReadAll(in)
+	if err != nil {
+		return err
+	}
+
+	entities := entity001{}
+	if err = json.Unmarshal(buffer, &entities); err != nil {
+		return err
+	}
+
+	// TODO(matt): This outer loop is a great basis for parallelization.
+	pendingSamples := model.Samples{}
+	for _, entity := range entities {
+		for _, value := range entity.Metric.Value {
+			labels := labelSet(entity.BaseLabels).Merge(labelSet(value.Labels))
+
+			switch entity.Metric.MetricType {
+			case gauge001, counter001:
+				sampleValue, ok := value.Value.(float64)
+				if !ok {
+					return fmt.Errorf("could not convert value from %s %s to float64", entity, value)
+				}
+
+				pendingSamples = append(pendingSamples, &model.Sample{
+					Metric:    model.Metric(labels),
+					Timestamp: o.Timestamp,
+					Value:     model.SampleValue(sampleValue),
+				})
+
+				break
+
+			case histogram001:
+				sampleValue, ok := value.Value.(map[string]interface{})
+				if !ok {
+					return fmt.Errorf("could not convert value from %q to a map[string]interface{}", value.Value)
+				}
+
+				for percentile, percentileValue := range sampleValue {
+					individualValue, ok := percentileValue.(float64)
+					if !ok {
+						return fmt.Errorf("could not convert value from %q to a float64", percentileValue)
+					}
+
+					childMetric := make(map[model.LabelName]model.LabelValue, len(labels)+1)
+
+					for k, v := range labels {
+						childMetric[k] = v
+					}
+
+					childMetric[model.LabelName(percentile001)] = model.LabelValue(percentile)
+
+					pendingSamples = append(pendingSamples, &model.Sample{
+						Metric:    model.Metric(childMetric),
+						Timestamp: o.Timestamp,
+						Value:     model.SampleValue(individualValue),
+					})
+				}
+
+				break
+			}
+		}
+	}
+	if len(pendingSamples) > 0 {
+		return out.Ingest(pendingSamples)
+	}
+
+	return nil
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/processor0_0_1_test.go

+// Copyright 2013 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 extraction
+
+import (
+	"errors"
+	"os"
+	"path"
+	"sort"
+	"testing"
+
+	"github.com/prometheus/client_golang/model"
+)
+
+var test001Time = model.Now()
+
+type testProcessor001ProcessScenario struct {
+	in               string
+	expected, actual []model.Samples
+	err              error
+}
+
+func (s *testProcessor001ProcessScenario) Ingest(samples model.Samples) error {
+	s.actual = append(s.actual, samples)
+	return nil
+}
+
+func (s *testProcessor001ProcessScenario) test(t testing.TB, set int) {
+	reader, err := os.Open(path.Join("fixtures", s.in))
+	if err != nil {
+		t.Fatalf("%d. couldn't open scenario input file %s: %s", set, s.in, err)
+	}
+
+	options := &ProcessOptions{
+		Timestamp: test001Time,
+	}
+	err = Processor001.ProcessSingle(reader, s, options)
+	if s.err != err && (s.err == nil || err == nil || err.Error() != s.err.Error()) {
+		t.Fatalf("%d. expected err of %s, got %s", set, s.err, err)
+	}
+
+	if len(s.actual) != len(s.expected) {
+		t.Fatalf("%d. expected output length of %d, got %d", set, len(s.expected), len(s.actual))
+	}
+
+	for i, expected := range s.expected {
+		sort.Sort(s.actual[i])
+		sort.Sort(expected)
+
+		if !expected.Equal(s.actual[i]) {
+			t.Errorf("%d.%d. expected %s, got %s", set, i, expected, s.actual[i])
+		}
+	}
+}
+
+func testProcessor001Process(t testing.TB) {
+	var scenarios = []testProcessor001ProcessScenario{
+		{
+			in:  "empty.json",
+			err: errors.New("unexpected end of JSON input"),
+		},
+		{
+			in: "test0_0_1-0_0_2.json",
+			expected: []model.Samples{
+				model.Samples{
+					&model.Sample{
+						Metric:    model.Metric{"service": "zed", model.MetricNameLabel: "rpc_calls_total", "job": "batch_job"},
+						Value:     25,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"service": "bar", model.MetricNameLabel: "rpc_calls_total", "job": "batch_job"},
+						Value:     25,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"service": "foo", model.MetricNameLabel: "rpc_calls_total", "job": "batch_job"},
+						Value:     25,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.010000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "zed"},
+						Value:     0.0459814091918713,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.010000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "bar"},
+						Value:     78.48563317257356,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.010000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "foo"},
+						Value:     15.890724674774395,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.050000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "zed"},
+						Value:     0.0459814091918713,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.050000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "bar"},
+						Value:     78.48563317257356,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.050000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "foo"},
+						Value:     15.890724674774395,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.500000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "zed"},
+						Value:     0.6120456642749681,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.500000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "bar"},
+						Value:     97.31798360385088,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.500000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "foo"},
+						Value:     84.63044031436561,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.900000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "zed"},
+						Value:     1.355915069887731,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.900000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "bar"},
+						Value:     109.89202084295582,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.900000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "foo"},
+						Value:     160.21100853053224,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.990000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "zed"},
+						Value:     1.772733213161236,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.990000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "bar"},
+						Value:     109.99626121011262,
+						Timestamp: test001Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.990000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "foo"},
+						Value:     172.49828748957728,
+						Timestamp: test001Time,
+					},
+				},
+			},
+		},
+	}
+
+	for i, scenario := range scenarios {
+		scenario.test(t, i)
+	}
+}
+
+func TestProcessor001Process(t *testing.T) {
+	testProcessor001Process(t)
+}
+
+func BenchmarkProcessor001Process(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		testProcessor001Process(b)
+	}
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/processor0_0_2.go

+// Copyright 2013 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 extraction
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+
+	"github.com/prometheus/client_golang/model"
+)
+
+// Processor002 is responsible for decoding payloads from protocol version
+// 0.0.2.
+var Processor002 = &processor002{}
+
+type histogram002 struct {
+	Labels map[string]string            `json:"labels"`
+	Values map[string]model.SampleValue `json:"value"`
+}
+
+type counter002 struct {
+	Labels map[string]string `json:"labels"`
+	Value  model.SampleValue `json:"value"`
+}
+
+type processor002 struct{}
+
+func (p *processor002) ProcessSingle(in io.Reader, out Ingester, o *ProcessOptions) error {
+	// Processor for telemetry schema version 0.0.2.
+	// container for telemetry data
+	var entities []struct {
+		BaseLabels map[string]string `json:"baseLabels"`
+		Docstring  string            `json:"docstring"`
+		Metric     struct {
+			Type   string          `json:"type"`
+			Values json.RawMessage `json:"value"`
+		} `json:"metric"`
+	}
+
+	if err := json.NewDecoder(in).Decode(&entities); err != nil {
+		return err
+	}
+
+	pendingSamples := model.Samples{}
+	for _, entity := range entities {
+		switch entity.Metric.Type {
+		case "counter", "gauge":
+			var values []counter002
+
+			if err := json.Unmarshal(entity.Metric.Values, &values); err != nil {
+				return fmt.Errorf("could not extract %s value: %s", entity.Metric.Type, err)
+			}
+
+			for _, counter := range values {
+				labels := labelSet(entity.BaseLabels).Merge(labelSet(counter.Labels))
+
+				pendingSamples = append(pendingSamples, &model.Sample{
+					Metric:    model.Metric(labels),
+					Timestamp: o.Timestamp,
+					Value:     counter.Value,
+				})
+			}
+
+		case "histogram":
+			var values []histogram002
+
+			if err := json.Unmarshal(entity.Metric.Values, &values); err != nil {
+				return fmt.Errorf("could not extract %s value: %s", entity.Metric.Type, err)
+			}
+
+			for _, histogram := range values {
+				for percentile, value := range histogram.Values {
+					labels := labelSet(entity.BaseLabels).Merge(labelSet(histogram.Labels))
+					labels[model.LabelName("percentile")] = model.LabelValue(percentile)
+
+					pendingSamples = append(pendingSamples, &model.Sample{
+						Metric:    model.Metric(labels),
+						Timestamp: o.Timestamp,
+						Value:     value,
+					})
+				}
+			}
+
+		default:
+			return fmt.Errorf("unknown metric type %q", entity.Metric.Type)
+		}
+	}
+
+	if len(pendingSamples) > 0 {
+		return out.Ingest(pendingSamples)
+	}
+
+	return nil
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/processor0_0_2_test.go

+// Copyright 2013 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 extraction
+
+import (
+	"bytes"
+	"errors"
+	"io/ioutil"
+	"os"
+	"path"
+	"runtime"
+	"sort"
+	"testing"
+
+	"github.com/prometheus/client_golang/model"
+)
+
+var test002Time = model.Now()
+
+type testProcessor002ProcessScenario struct {
+	in               string
+	expected, actual []model.Samples
+	err              error
+}
+
+func (s *testProcessor002ProcessScenario) Ingest(samples model.Samples) error {
+	s.actual = append(s.actual, samples)
+	return nil
+}
+
+func (s *testProcessor002ProcessScenario) test(t testing.TB, set int) {
+	reader, err := os.Open(path.Join("fixtures", s.in))
+	if err != nil {
+		t.Fatalf("%d. couldn't open scenario input file %s: %s", set, s.in, err)
+	}
+
+	options := &ProcessOptions{
+		Timestamp: test002Time,
+	}
+	err = Processor002.ProcessSingle(reader, s, options)
+	if s.err != err && (s.err == nil || err == nil || err.Error() != s.err.Error()) {
+		t.Fatalf("%d. expected err of %s, got %s", set, s.err, err)
+	}
+
+	if len(s.actual) != len(s.expected) {
+		t.Fatalf("%d. expected output length of %d, got %d", set, len(s.expected), len(s.actual))
+	}
+
+	for i, expected := range s.expected {
+		sort.Sort(s.actual[i])
+		sort.Sort(expected)
+
+		if !expected.Equal(s.actual[i]) {
+			t.Fatalf("%d.%d. expected %s, got %s", set, i, expected, s.actual[i])
+		}
+	}
+}
+
+func testProcessor002Process(t testing.TB) {
+	var scenarios = []testProcessor002ProcessScenario{
+		{
+			in:  "empty.json",
+			err: errors.New("EOF"),
+		},
+		{
+			in: "test0_0_1-0_0_2.json",
+			expected: []model.Samples{
+				model.Samples{
+					&model.Sample{
+						Metric:    model.Metric{"service": "zed", model.MetricNameLabel: "rpc_calls_total", "job": "batch_job"},
+						Value:     25,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"service": "bar", model.MetricNameLabel: "rpc_calls_total", "job": "batch_job"},
+						Value:     25,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"service": "foo", model.MetricNameLabel: "rpc_calls_total", "job": "batch_job"},
+						Value:     25,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.010000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "zed"},
+						Value:     0.0459814091918713,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.010000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "bar"},
+						Value:     78.48563317257356,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.010000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "foo"},
+						Value:     15.890724674774395,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+
+						Metric:    model.Metric{"percentile": "0.050000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "zed"},
+						Value:     0.0459814091918713,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.050000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "bar"},
+						Value:     78.48563317257356,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.050000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "foo"},
+						Value:     15.890724674774395,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.500000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "zed"},
+						Value:     0.6120456642749681,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.500000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "bar"},
+						Value:     97.31798360385088,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.500000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "foo"},
+						Value:     84.63044031436561,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.900000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "zed"},
+						Value:     1.355915069887731,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.900000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "bar"},
+						Value:     109.89202084295582,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.900000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "foo"},
+						Value:     160.21100853053224,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.990000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "zed"},
+						Value:     1.772733213161236,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.990000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "bar"},
+						Value:     109.99626121011262,
+						Timestamp: test002Time,
+					},
+					&model.Sample{
+						Metric:    model.Metric{"percentile": "0.990000", model.MetricNameLabel: "rpc_latency_microseconds", "service": "foo"},
+						Value:     172.49828748957728,
+						Timestamp: test002Time,
+					},
+				},
+			},
+		},
+	}
+
+	for i, scenario := range scenarios {
+		scenario.test(t, i)
+	}
+}
+
+func TestProcessor002Process(t *testing.T) {
+	testProcessor002Process(t)
+}
+
+func BenchmarkProcessor002Process(b *testing.B) {
+	b.StopTimer()
+
+	pre := runtime.MemStats{}
+	runtime.ReadMemStats(&pre)
+
+	b.StartTimer()
+
+	for i := 0; i < b.N; i++ {
+		testProcessor002Process(b)
+	}
+
+	post := runtime.MemStats{}
+	runtime.ReadMemStats(&post)
+
+	allocated := post.TotalAlloc - pre.TotalAlloc
+
+	b.Logf("Allocated %d at %f per cycle with %d cycles.", allocated, float64(allocated)/float64(b.N), b.N)
+}
+
+func BenchmarkProcessor002ParseOnly(b *testing.B) {
+	b.StopTimer()
+	data, err := ioutil.ReadFile("fixtures/test0_0_1-0_0_2-large.json")
+	if err != nil {
+		b.Fatal(err)
+	}
+	ing := fakeIngester{}
+	b.StartTimer()
+
+	for i := 0; i < b.N; i++ {
+		if err := Processor002.ProcessSingle(bytes.NewReader(data), ing, &ProcessOptions{}); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+type fakeIngester struct{}
+
+func (i fakeIngester) Ingest(model.Samples) error {
+	return nil
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/textprocessor.go

+// Copyright 2014 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 extraction
+
+import (
+	"io"
+
+	"github.com/prometheus/client_golang/text"
+)
+
+type processor004 struct{}
+
+// Processor004 s responsible for decoding payloads from the text based variety
+// of protocol version 0.0.4.
+var Processor004 = &processor004{}
+
+func (t *processor004) ProcessSingle(i io.Reader, out Ingester, o *ProcessOptions) error {
+	var parser text.Parser
+	metricFamilies, err := parser.TextToMetricFamilies(i)
+	if err != nil {
+		return err
+	}
+	for _, metricFamily := range metricFamilies {
+		if err := extractMetricFamily(out, o, metricFamily); err != nil {
+			return err
+		}
+	}
+	return nil
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/extraction/textprocessor_test.go

+// Copyright 2014 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 extraction
+
+import (
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/prometheus/client_golang/model"
+)
+
+var (
+	ts = model.Now()
+	in = `
+# Only a quite simple scenario with two metric families.
+# More complicated tests of the parser itself can be found in the text package.
+# TYPE mf2 counter
+mf2 3
+mf1{label="value1"} -3.14 123456
+mf1{label="value2"} 42
+mf2 4
+`
+	out = map[model.LabelValue]model.Samples{
+		"mf1": model.Samples{
+			&model.Sample{
+				Metric:    model.Metric{model.MetricNameLabel: "mf1", "label": "value1"},
+				Value:     -3.14,
+				Timestamp: 123456,
+			},
+			&model.Sample{
+				Metric:    model.Metric{model.MetricNameLabel: "mf1", "label": "value2"},
+				Value:     42,
+				Timestamp: ts,
+			},
+		},
+		"mf2": model.Samples{
+			&model.Sample{
+				Metric:    model.Metric{model.MetricNameLabel: "mf2"},
+				Value:     3,
+				Timestamp: ts,
+			},
+			&model.Sample{
+				Metric:    model.Metric{model.MetricNameLabel: "mf2"},
+				Value:     4,
+				Timestamp: ts,
+			},
+		},
+	}
+)
+
+type testIngester struct {
+	results []model.Samples
+}
+
+func (i *testIngester) Ingest(s model.Samples) error {
+	i.results = append(i.results, s)
+	return nil
+}
+
+func TestTextProcessor(t *testing.T) {
+	var ingester testIngester
+	i := strings.NewReader(in)
+	o := &ProcessOptions{
+		Timestamp: ts,
+	}
+
+	err := Processor004.ProcessSingle(i, &ingester, o)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if expected, got := len(out), len(ingester.results); expected != got {
+		t.Fatalf("Expected length %d, got %d", expected, got)
+	}
+	for _, r := range ingester.results {
+		expected, ok := out[r[0].Metric[model.MetricNameLabel]]
+		if !ok {
+			t.Fatalf(
+				"Unexpected metric name %q",
+				r[0].Metric[model.MetricNameLabel],
+			)
+		}
+		sort.Sort(expected)
+		sort.Sort(r)
+		if !expected.Equal(r) {
+			t.Errorf("expected %s, got %s", expected, r)
+		}
+	}
+}

Godeps/_workspace/src/github.com/prometheus/common/model/fingerprinting.go → Godeps/_workspace/src/github.com/prometheus/client_golang/model/fingerprinting.go

@@ -22,23 +22,28 @@ import (
 // For our purposes, FNV-1A 64-bit is used.
 type Fingerprint uint64
 
-// FingerprintFromString transforms a string representation into a Fingerprint.
-func FingerprintFromString(s string) (Fingerprint, error) {
-	num, err := strconv.ParseUint(s, 16, 64)
-	return Fingerprint(num), err
+func (f Fingerprint) String() string {
+	return fmt.Sprintf("%016x", uint64(f))
+}
+
+// Less implements sort.Interface.
+func (f Fingerprint) Less(o Fingerprint) bool {
+	return f < o
 }
 
-// ParseFingerprint parses the input string into a fingerprint.
-func ParseFingerprint(s string) (Fingerprint, error) {
+// Equal implements sort.Interface.
+func (f Fingerprint) Equal(o Fingerprint) bool {
+	return f == o
+}
+
+// LoadFromString transforms a string representation into a Fingerprint.
+func (f *Fingerprint) LoadFromString(s string) error {
 	num, err := strconv.ParseUint(s, 16, 64)
 	if err != nil {
-		return 0, err
+		return err
 	}
-	return Fingerprint(num), nil
-}
-
-func (f Fingerprint) String() string {
-	return fmt.Sprintf("%016x", uint64(f))
+	*f = Fingerprint(num)
+	return nil
 }
 
 // Fingerprints represents a collection of Fingerprint subject to a given

Godeps/_workspace/src/github.com/prometheus/client_golang/model/labelname.go

+// Copyright 2013 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 model
+
+import (
+	"strings"
+)
+
+const (
+	// ExporterLabelPrefix is the label name prefix to prepend if a
+	// synthetic label is already present in the exported metrics.
+	ExporterLabelPrefix LabelName = "exporter_"
+
+	// MetricNameLabel is the label name indicating the metric name of a
+	// timeseries.
+	MetricNameLabel LabelName = "__name__"
+
+	// ReservedLabelPrefix is a prefix which is not legal in user-supplied
+	// label names.
+	ReservedLabelPrefix = "__"
+
+	// JobLabel is the label name indicating the job from which a timeseries
+	// was scraped.
+	JobLabel LabelName = "job"
+
+	// BucketLabel is used for the label that defines the upper bound of a
+	// bucket of a histogram ("le" -> "less or equal").
+	BucketLabel = "le"
+
+	// QuantileLabel is used for the label that defines the quantile in a
+	// summary.
+	QuantileLabel = "quantile"
+)
+
+// A LabelName is a key for a LabelSet or Metric.  It has a value associated
+// therewith.
+type LabelName string
+
+// LabelNames is a sortable LabelName slice. In implements sort.Interface.
+type LabelNames []LabelName
+
+func (l LabelNames) Len() int {
+	return len(l)
+}
+
+func (l LabelNames) Less(i, j int) bool {
+	return l[i] < l[j]
+}
+
+func (l LabelNames) Swap(i, j int) {
+	l[i], l[j] = l[j], l[i]
+}
+
+func (l LabelNames) String() string {
+	labelStrings := make([]string, 0, len(l))
+	for _, label := range l {
+		labelStrings = append(labelStrings, string(label))
+	}
+	return strings.Join(labelStrings, ", ")
+}

Godeps/_workspace/src/github.com/prometheus/common/model/labels_test.go → Godeps/_workspace/src/github.com/prometheus/client_golang/model/labelname_test.go

@@ -53,39 +53,3 @@ func BenchmarkLabelNames(b *testing.B) {
 		testLabelNames(b)
 	}
 }
-
-func testLabelValues(t testing.TB) {
-	var scenarios = []struct {
-		in  LabelValues
-		out LabelValues
-	}{
-		{
-			in:  LabelValues{"ZZZ", "zzz"},
-			out: LabelValues{"ZZZ", "zzz"},
-		},
-		{
-			in:  LabelValues{"aaa", "AAA"},
-			out: LabelValues{"AAA", "aaa"},
-		},
-	}
-
-	for i, scenario := range scenarios {
-		sort.Sort(scenario.in)
-
-		for j, expected := range scenario.out {
-			if expected != scenario.in[j] {
-				t.Errorf("%d.%d expected %s, got %s", i, j, expected, scenario.in[j])
-			}
-		}
-	}
-}
-
-func TestLabelValues(t *testing.T) {
-	testLabelValues(t)
-}
-
-func BenchmarkLabelValues(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		testLabelValues(b)
-	}
-}

Godeps/_workspace/src/github.com/prometheus/client_golang/model/labelset.go

+// Copyright 2013 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 model
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// A LabelSet is a collection of LabelName and LabelValue pairs.  The LabelSet
+// may be fully-qualified down to the point where it may resolve to a single
+// Metric in the data store or not.  All operations that occur within the realm
+// of a LabelSet can emit a vector of Metric entities to which the LabelSet may
+// match.
+type LabelSet map[LabelName]LabelValue
+
+// Merge is a helper function to non-destructively merge two label sets.
+func (l LabelSet) Merge(other LabelSet) LabelSet {
+	result := make(LabelSet, len(l))
+
+	for k, v := range l {
+		result[k] = v
+	}
+
+	for k, v := range other {
+		result[k] = v
+	}
+
+	return result
+}
+
+func (l LabelSet) String() string {
+	labelStrings := make([]string, 0, len(l))
+	for label, value := range l {
+		labelStrings = append(labelStrings, fmt.Sprintf("%s=%q", label, value))
+	}
+
+	switch len(labelStrings) {
+	case 0:
+		return ""
+	default:
+		sort.Strings(labelStrings)
+		return fmt.Sprintf("{%s}", strings.Join(labelStrings, ", "))
+	}
+}
+
+// MergeFromMetric merges Metric into this LabelSet.
+func (l LabelSet) MergeFromMetric(m Metric) {
+	for k, v := range m {
+		l[k] = v
+	}
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/model/labelvalue.go

+// Copyright 2013 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 model
+
+import (
+	"sort"
+)
+
+// A LabelValue is an associated value for a LabelName.
+type LabelValue string
+
+// LabelValues is a sortable LabelValue slice. It implements sort.Interface.
+type LabelValues []LabelValue
+
+func (l LabelValues) Len() int {
+	return len(l)
+}
+
+func (l LabelValues) Less(i, j int) bool {
+	return sort.StringsAreSorted([]string{string(l[i]), string(l[j])})
+}
+
+func (l LabelValues) Swap(i, j int) {
+	l[i], l[j] = l[j], l[i]
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/model/labelvalue_test.go

+// Copyright 2013 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 model
+
+import (
+	"sort"
+	"testing"
+)
+
+func testLabelValues(t testing.TB) {
+	var scenarios = []struct {
+		in  LabelValues
+		out LabelValues
+	}{
+		{
+			in:  LabelValues{"ZZZ", "zzz"},
+			out: LabelValues{"ZZZ", "zzz"},
+		},
+		{
+			in:  LabelValues{"aaa", "AAA"},
+			out: LabelValues{"AAA", "aaa"},
+		},
+	}
+
+	for i, scenario := range scenarios {
+		sort.Sort(scenario.in)
+
+		for j, expected := range scenario.out {
+			if expected != scenario.in[j] {
+				t.Errorf("%d.%d expected %s, got %s", i, j, expected, scenario.in[j])
+			}
+		}
+	}
+}
+
+func TestLabelValues(t *testing.T) {
+	testLabelValues(t)
+}
+
+func BenchmarkLabelValues(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		testLabelValues(b)
+	}
+}

Godeps/_workspace/src/github.com/prometheus/common/model/metric.go → Godeps/_workspace/src/github.com/prometheus/client_golang/model/metric.go

@@ -14,6 +14,7 @@
 package model
 
 import (
+	"encoding/json"
 	"fmt"
 	"sort"
 	"strings"
@@ -23,27 +24,19 @@ var separator = []byte{0}
 
 // A Metric is similar to a LabelSet, but the key difference is that a Metric is
 // a singleton and refers to one and only one stream of samples.
-type Metric LabelSet
+type Metric map[LabelName]LabelValue
 
-// Equal compares the metrics.
+// Equal compares the fingerprints of both metrics.
 func (m Metric) Equal(o Metric) bool {
-	return LabelSet(m).Equal(LabelSet(o))
+	return m.Fingerprint().Equal(o.Fingerprint())
 }
 
-// Before compares the metrics' underlying label sets.
+// Before compares the fingerprints of both metrics.
 func (m Metric) Before(o Metric) bool {
-	return LabelSet(m).Before(LabelSet(o))
-}
-
-// Clone returns a copy of the Metric.
-func (m Metric) Clone() Metric {
-	clone := Metric{}
-	for k, v := range m {
-		clone[k] = v
-	}
-	return clone
+	return m.Fingerprint().Less(o.Fingerprint())
 }
 
+// String implements Stringer.
 func (m Metric) String() string {
 	metricName, hasName := m[MetricNameLabel]
 	numLabels := len(m) - 1
@@ -71,11 +64,69 @@ func (m Metric) String() string {
 
 // Fingerprint returns a Metric's Fingerprint.
 func (m Metric) Fingerprint() Fingerprint {
-	return LabelSet(m).Fingerprint()
+	return metricToFingerprint(m)
+}
+
+// Clone returns a copy of the Metric.
+func (m Metric) Clone() Metric {
+	clone := Metric{}
+	for k, v := range m {
+		clone[k] = v
+	}
+	return clone
+}
+
+// MergeFromLabelSet merges a label set into this Metric, prefixing a collision
+// prefix to the label names merged from the label set where required.
+func (m Metric) MergeFromLabelSet(labels LabelSet, collisionPrefix LabelName) {
+	for k, v := range labels {
+		if collisionPrefix != "" {
+			for {
+				if _, exists := m[k]; !exists {
+					break
+				}
+				k = collisionPrefix + k
+			}
+		}
+
+		m[k] = v
+	}
+}
+
+// COWMetric wraps a Metric to enable copy-on-write access patterns.
+type COWMetric struct {
+	Copied bool
+	Metric Metric
+}
+
+// Set sets a label name in the wrapped Metric to a given value and copies the
+// Metric initially, if it is not already a copy.
+func (m *COWMetric) Set(ln LabelName, lv LabelValue) {
+	m.doCOW()
+	m.Metric[ln] = lv
+}
+
+// Delete deletes a given label name from the wrapped Metric and copies the
+// Metric initially, if it is not already a copy.
+func (m *COWMetric) Delete(ln LabelName) {
+	m.doCOW()
+	delete(m.Metric, ln)
+}
+
+// doCOW copies the underlying Metric if it is not already a copy.
+func (m *COWMetric) doCOW() {
+	if !m.Copied {
+		m.Metric = m.Metric.Clone()
+		m.Copied = true
+	}
+}
+
+// String implements fmt.Stringer.
+func (m COWMetric) String() string {
+	return m.Metric.String()
 }
 
-// FastFingerprint returns a Metric's Fingerprint calculated by a faster hashing
-// algorithm, which is, however, more susceptible to hash collisions.
-func (m Metric) FastFingerprint() Fingerprint {
-	return LabelSet(m).FastFingerprint()
+// MarshalJSON implements json.Marshaler.
+func (m COWMetric) MarshalJSON() ([]byte, error) {
+	return json.Marshal(m.Metric)
 }

Godeps/_workspace/src/github.com/prometheus/common/model/metric_test.go → Godeps/_workspace/src/github.com/prometheus/client_golang/model/metric_test.go

@@ -17,57 +17,46 @@ import "testing"
 
 func testMetric(t testing.TB) {
 	var scenarios = []struct {
-		input           LabelSet
-		fingerprint     Fingerprint
-		fastFingerprint Fingerprint
+		input       Metric
+		fingerprint Fingerprint
 	}{
 		{
-			input:           LabelSet{},
-			fingerprint:     14695981039346656037,
-			fastFingerprint: 14695981039346656037,
+			input:       Metric{},
+			fingerprint: 14695981039346656037,
 		},
 		{
-			input: LabelSet{
+			input: Metric{
 				"first_name":   "electro",
 				"occupation":   "robot",
 				"manufacturer": "westinghouse",
 			},
-			fingerprint:     5911716720268894962,
-			fastFingerprint: 11310079640881077873,
+			fingerprint: 11310079640881077873,
 		},
 		{
-			input: LabelSet{
+			input: Metric{
 				"x": "y",
 			},
-			fingerprint:     8241431561484471700,
-			fastFingerprint: 13948396922932177635,
+			fingerprint: 13948396922932177635,
 		},
 		{
-			input: LabelSet{
+			input: Metric{
 				"a": "bb",
 				"b": "c",
 			},
-			fingerprint:     3016285359649981711,
-			fastFingerprint: 3198632812309449502,
+			fingerprint: 3198632812309449502,
 		},
 		{
-			input: LabelSet{
+			input: Metric{
 				"a":  "b",
 				"bb": "c",
 			},
-			fingerprint:     7122421792099404749,
-			fastFingerprint: 5774953389407657638,
+			fingerprint: 5774953389407657638,
 		},
 	}
 
 	for i, scenario := range scenarios {
-		input := Metric(scenario.input)
-
-		if scenario.fingerprint != input.Fingerprint() {
-			t.Errorf("%d. expected %d, got %d", i, scenario.fingerprint, input.Fingerprint())
-		}
-		if scenario.fastFingerprint != input.FastFingerprint() {
-			t.Errorf("%d. expected %d, got %d", i, scenario.fastFingerprint, input.FastFingerprint())
+		if scenario.fingerprint != scenario.input.Fingerprint() {
+			t.Errorf("%d. expected %d, got %d", i, scenario.fingerprint, scenario.input.Fingerprint())
 		}
 	}
 }
@@ -81,3 +70,52 @@ func BenchmarkMetric(b *testing.B) {
 		testMetric(b)
 	}
 }
+
+func TestCOWMetric(t *testing.T) {
+	testMetric := Metric{
+		"to_delete": "test1",
+		"to_change": "test2",
+	}
+
+	scenarios := []struct {
+		fn  func(*COWMetric)
+		out Metric
+	}{
+		{
+			fn: func(cm *COWMetric) {
+				cm.Delete("to_delete")
+			},
+			out: Metric{
+				"to_change": "test2",
+			},
+		},
+		{
+			fn: func(cm *COWMetric) {
+				cm.Set("to_change", "changed")
+			},
+			out: Metric{
+				"to_delete": "test1",
+				"to_change": "changed",
+			},
+		},
+	}
+
+	for i, s := range scenarios {
+		orig := testMetric.Clone()
+		cm := &COWMetric{
+			Metric: orig,
+		}
+
+		s.fn(cm)
+
+		// Test that the original metric was not modified.
+		if !orig.Equal(testMetric) {
+			t.Fatalf("%d. original metric changed; expected %v, got %v", i, testMetric, orig)
+		}
+
+		// Test that the new metric has the right changes.
+		if !cm.Metric.Equal(s.out) {
+			t.Fatalf("%d. copied metric doesn't contain expected changes; expected %v, got %v", i, s.out, cm.Metric)
+		}
+	}
+}

Godeps/_workspace/src/github.com/prometheus/common/model/model.go → Godeps/_workspace/src/github.com/prometheus/client_golang/model/model.go

@@ -11,6 +11,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package model contains common data structures that are shared across
-// Prometheus componenets and libraries.
+// Package model contains core representation of Prometheus client primitives.
 package model

Godeps/_workspace/src/github.com/prometheus/client_golang/model/sample.go

+// Copyright 2013 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 model
+
+// Sample is a sample value with a timestamp and a metric.
+type Sample struct {
+	Metric    Metric
+	Value     SampleValue
+	Timestamp Timestamp
+}
+
+// Equal compares first the metrics, then the timestamp, then the value.
+func (s *Sample) Equal(o *Sample) bool {
+	if s == o {
+		return true
+	}
+
+	if !s.Metric.Equal(o.Metric) {
+		return false
+	}
+	if !s.Timestamp.Equal(o.Timestamp) {
+		return false
+	}
+	if !s.Value.Equal(o.Value) {
+		return false
+	}
+
+	return true
+}
+
+// Samples is a sortable Sample slice. It implements sort.Interface.
+type Samples []*Sample
+
+func (s Samples) Len() int {
+	return len(s)
+}
+
+// Less compares first the metrics, then the timestamp.
+func (s Samples) Less(i, j int) bool {
+	switch {
+	case s[i].Metric.Before(s[j].Metric):
+		return true
+	case s[j].Metric.Before(s[i].Metric):
+		return false
+	case s[i].Timestamp.Before(s[j].Timestamp):
+		return true
+	default:
+		return false
+	}
+}
+
+func (s Samples) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+// Equal compares two sets of samples and returns true if they are equal.
+func (s Samples) Equal(o Samples) bool {
+	if len(s) != len(o) {
+		return false
+	}
+
+	for i, sample := range s {
+		if !sample.Equal(o[i]) {
+			return false
+		}
+	}
+	return true
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/model/sample_test.go

+// Copyright 2013 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 model
+
+import (
+	"sort"
+	"testing"
+)
+
+func TestSamplesSort(t *testing.T) {
+	input := Samples{
+		&Sample{
+			// Fingerprint: 81f9c9ed24563f8f.
+			Metric: Metric{
+				MetricNameLabel: "A",
+			},
+			Timestamp: 1,
+		},
+		&Sample{
+			// Fingerprint: 81f9c9ed24563f8f.
+			Metric: Metric{
+				MetricNameLabel: "A",
+			},
+			Timestamp: 2,
+		},
+		&Sample{
+			// Fingerprint: 1bf6c9ed24543f8f.
+			Metric: Metric{
+				MetricNameLabel: "C",
+			},
+			Timestamp: 1,
+		},
+		&Sample{
+			// Fingerprint: 1bf6c9ed24543f8f.
+			Metric: Metric{
+				MetricNameLabel: "C",
+			},
+			Timestamp: 2,
+		},
+		&Sample{
+			// Fingerprint: 68f4c9ed24533f8f.
+			Metric: Metric{
+				MetricNameLabel: "B",
+			},
+			Timestamp: 1,
+		},
+		&Sample{
+			// Fingerprint: 68f4c9ed24533f8f.
+			Metric: Metric{
+				MetricNameLabel: "B",
+			},
+			Timestamp: 2,
+		},
+	}
+
+	expected := Samples{
+		&Sample{
+			// Fingerprint: 1bf6c9ed24543f8f.
+			Metric: Metric{
+				MetricNameLabel: "C",
+			},
+			Timestamp: 1,
+		},
+		&Sample{
+			// Fingerprint: 1bf6c9ed24543f8f.
+			Metric: Metric{
+				MetricNameLabel: "C",
+			},
+			Timestamp: 2,
+		},
+		&Sample{
+			// Fingerprint: 68f4c9ed24533f8f.
+			Metric: Metric{
+				MetricNameLabel: "B",
+			},
+			Timestamp: 1,
+		},
+		&Sample{
+			// Fingerprint: 68f4c9ed24533f8f.
+			Metric: Metric{
+				MetricNameLabel: "B",
+			},
+			Timestamp: 2,
+		},
+		&Sample{
+			// Fingerprint: 81f9c9ed24563f8f.
+			Metric: Metric{
+				MetricNameLabel: "A",
+			},
+			Timestamp: 1,
+		},
+		&Sample{
+			// Fingerprint: 81f9c9ed24563f8f.
+			Metric: Metric{
+				MetricNameLabel: "A",
+			},
+			Timestamp: 2,
+		},
+	}
+
+	sort.Sort(input)
+
+	for i, actual := range input {
+		actualFp := actual.Metric.Fingerprint()
+		expectedFp := expected[i].Metric.Fingerprint()
+
+		if !actualFp.Equal(expectedFp) {
+			t.Fatalf("%d. Incorrect fingerprint. Got %s; want %s", i, actualFp.String(), expectedFp.String())
+		}
+
+		if actual.Timestamp != expected[i].Timestamp {
+			t.Fatalf("%d. Incorrect timestamp. Got %s; want %s", i, actual.Timestamp, expected[i].Timestamp)
+		}
+	}
+}

Godeps/_workspace/src/github.com/prometheus/client_golang/model/samplevalue.go

+// Copyright 2013 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 model
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// A SampleValue is a representation of a value for a given sample at a given
+// time.
+type SampleValue float64
+
+// Equal does a straight v==o.
+func (v SampleValue) Equal(o SampleValue) bool {
+	return v == o
+}
+
+// MarshalJSON implements json.Marshaler.
+func (v SampleValue) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf(`"%s"`, v)), nil
+}
+
+func (v SampleValue) String() string {
+	return strconv.FormatFloat(float64(v), 'f', -1, 64)
+}

Godeps/_workspace/src/github.com/prometheus/common/model/signature.go → Godeps/_workspace/src/github.com/prometheus/client_golang/model/signature.go

@@ -17,7 +17,6 @@ import (
 	"bytes"
 	"hash"
 	"hash/fnv"
-	"sort"
 	"sync"
 )
 
@@ -47,71 +46,36 @@ func getHashAndBuf() *hashAndBuf {
 }
 
 func putHashAndBuf(hb *hashAndBuf) {
-	hb.h.Reset()
-	hb.b.Reset()
 	hashAndBufPool.Put(hb)
 }
 
-// LabelsToSignature returns a quasi-unique signature (i.e., fingerprint) for a
-// given label set. (Collisions are possible but unlikely if the number of label
-// sets the function is applied to is small.)
+// LabelsToSignature returns a unique signature (i.e., fingerprint) for a given
+// label set.
 func LabelsToSignature(labels map[string]string) uint64 {
 	if len(labels) == 0 {
 		return emptyLabelSignature
 	}
 
-	labelNames := make([]string, 0, len(labels))
-	for labelName := range labels {
-		labelNames = append(labelNames, labelName)
-	}
-	sort.Strings(labelNames)
-
+	var result uint64
 	hb := getHashAndBuf()
 	defer putHashAndBuf(hb)
 
-	for _, labelName := range labelNames {
+	for labelName, labelValue := range labels {
 		hb.b.WriteString(labelName)
 		hb.b.WriteByte(SeparatorByte)
-		hb.b.WriteString(labels[labelName])
-		hb.b.WriteByte(SeparatorByte)
+		hb.b.WriteString(labelValue)
 		hb.h.Write(hb.b.Bytes())
+		result ^= hb.h.Sum64()
+		hb.h.Reset()
 		hb.b.Reset()
 	}
-	return hb.h.Sum64()
+	return result
 }
 
-// labelSetToFingerprint works exactly as LabelsToSignature but takes a LabelSet as
+// metricToFingerprint works exactly as LabelsToSignature but takes a Metric as
 // parameter (rather than a label map) and returns a Fingerprint.
-func labelSetToFingerprint(ls LabelSet) Fingerprint {
-	if len(ls) == 0 {
-		return Fingerprint(emptyLabelSignature)
-	}
-
-	labelNames := make(LabelNames, 0, len(ls))
-	for labelName := range ls {
-		labelNames = append(labelNames, labelName)
-	}
-	sort.Sort(labelNames)
-
-	hb := getHashAndBuf()
-	defer putHashAndBuf(hb)
-
-	for _, labelName := range labelNames {
-		hb.b.WriteString(string(labelName))
-		hb.b.WriteByte(SeparatorByte)
-		hb.b.WriteString(string(ls[labelName]))
-		hb.b.WriteByte(SeparatorByte)
-		hb.h.Write(hb.b.Bytes())
-		hb.b.Reset()
-	}
-	return Fingerprint(hb.h.Sum64())
-}
-
-// labelSetToFastFingerprint works similar to labelSetToFingerprint but uses a
-// faster and less allocation-heavy hash function, which is more susceptible to
-// create hash collisions. Therefore, collision detection should be applied.
-func labelSetToFastFingerprint(ls LabelSet) Fingerprint {
-	if len(ls) == 0 {
+func metricToFingerprint(m Metric) Fingerprint {
+	if len(m) == 0 {
 		return Fingerprint(emptyLabelSignature)
 	}
 
@@ -119,7 +83,7 @@ func labelSetToFastFingerprint(ls LabelSet) Fingerprint {
 	hb := getHashAndBuf()
 	defer putHashAndBuf(hb)
 
-	for labelName, labelValue := range ls {
+	for labelName, labelValue := range m {
 		hb.b.WriteString(string(labelName))
 		hb.b.WriteByte(SeparatorByte)
 		hb.b.WriteString(string(labelValue))
@@ -133,15 +97,13 @@ func labelSetToFastFingerprint(ls LabelSet) Fingerprint {
 
 // SignatureForLabels works like LabelsToSignature but takes a Metric as
 // parameter (rather than a label map) and only includes the labels with the
-// specified LabelNames into the signature calculation. The labels passed in
-// will be sorted by this function.
-func SignatureForLabels(m Metric, labels ...LabelName) uint64 {
+// specified LabelNames into the signature calculation.
+func SignatureForLabels(m Metric, labels LabelNames) uint64 {
 	if len(m) == 0 || len(labels) == 0 {
 		return emptyLabelSignature
 	}
 
-	sort.Sort(LabelNames(labels))
-
+	var result uint64
 	hb := getHashAndBuf()
 	defer putHashAndBuf(hb)
 
@@ -149,11 +111,12 @@ func SignatureForLabels(m Metric, labels ...LabelName) uint64 {
 		hb.b.WriteString(string(label))
 		hb.b.WriteByte(SeparatorByte)
 		hb.b.WriteString(string(m[label]))
-		hb.b.WriteByte(SeparatorByte)
 		hb.h.Write(hb.b.Bytes())
+		result ^= hb.h.Sum64()
+		hb.h.Reset()
 		hb.b.Reset()
 	}
-	return hb.h.Sum64()
+	return result
 }
 
 // SignatureWithoutLabels works like LabelsToSignature but takes a Metric as
@@ -164,27 +127,24 @@ func SignatureWithoutLabels(m Metric, labels map[LabelName]struct{}) uint64 {
 		return emptyLabelSignature
 	}
 
-	labelNames := make(LabelNames, 0, len(m))
-	for labelName := range m {
-		if _, exclude := labels[labelName]; !exclude {
-			labelNames = append(labelNames, labelName)
-		}
-	}
-	if len(labelNames) == 0 {
-		return emptyLabelSignature
-	}
-	sort.Sort(labelNames)
-
+	var result uint64
 	hb := getHashAndBuf()
 	defer putHashAndBuf(hb)
 
-	for _, labelName := range labelNames {
+	for labelName, labelValue := range m {
+		if _, exclude := labels[labelName]; exclude {
+			continue
+		}
 		hb.b.WriteString(string(labelName))
 		hb.b.WriteByte(SeparatorByte)
-		hb.b.WriteString(string(m[labelName]))
-		hb.b.WriteByte(SeparatorByte)
+		hb.b.WriteString(string(labelValue))
 		hb.h.Write(hb.b.Bytes())
+		result ^= hb.h.Sum64()
+		hb.h.Reset()
 		hb.b.Reset()
 	}
-	return hb.h.Sum64()
+	if result == 0 {
+		return emptyLabelSignature
+	}
+	return result
 }

Godeps/_workspace/src/github.com/prometheus/common/model/signature_test.go → Godeps/_workspace/src/github.com/prometheus/client_golang/model/signature_test.go

@@ -30,7 +30,7 @@ func TestLabelsToSignature(t *testing.T) {
 		},
 		{
 			in:  map[string]string{"name": "garland, briggs", "fear": "love is not enough"},
-			out: 5799056148416392346,
+			out: 12952432476264840823,
 		},
 	}
 
@@ -45,45 +45,21 @@ func TestLabelsToSignature(t *testing.T) {
 
 func TestMetricToFingerprint(t *testing.T) {
 	var scenarios = []struct {
-		in  LabelSet
-		out Fingerprint
-	}{
-		{
-			in:  LabelSet{},
-			out: 14695981039346656037,
-		},
-		{
-			in:  LabelSet{"name": "garland, briggs", "fear": "love is not enough"},
-			out: 5799056148416392346,
-		},
-	}
-
-	for i, scenario := range scenarios {
-		actual := labelSetToFingerprint(scenario.in)
-
-		if actual != scenario.out {
-			t.Errorf("%d. expected %d, got %d", i, scenario.out, actual)
-		}
-	}
-}
-
-func TestMetricToFastFingerprint(t *testing.T) {
-	var scenarios = []struct {
-		in  LabelSet
+		in  Metric
 		out Fingerprint
 	}{
 		{
-			in:  LabelSet{},
+			in:  Metric{},
 			out: 14695981039346656037,
 		},
 		{
-			in:  LabelSet{"name": "garland, briggs", "fear": "love is not enough"},
+			in:  Metric{"name": "garland, briggs", "fear": "love is not enough"},
 			out: 12952432476264840823,
 		},
 	}
 
 	for i, scenario := range scenarios {
-		actual := labelSetToFastFingerprint(scenario.in)
+		actual := metricToFingerprint(scenario.in)
 
 		if actual != scenario.out {
 			t.Errorf("%d. expected %d, got %d", i, scenario.out, actual)
@@ -105,12 +81,12 @@ func TestSignatureForLabels(t *testing.T) {
 		{
 			in:     Metric{"name": "garland, briggs", "fear": "love is not enough"},
 			labels: LabelNames{"fear", "name"},
-			out:    5799056148416392346,
+			out:    12952432476264840823,
 		},
 		{
 			in:     Metric{"name": "garland, briggs", "fear": "love is not enough", "foo": "bar"},
 			labels: LabelNames{"fear", "name"},
-			out:    5799056148416392346,
+			out:    12952432476264840823,
 		},
 		{
 			in:     Metric{"name": "garland, briggs", "fear": "love is not enough"},
@@ -125,7 +101,7 @@ func TestSignatureForLabels(t *testing.T) {
 	}
 
 	for i, scenario := range scenarios {
-		actual := SignatureForLabels(scenario.in, scenario.labels...)
+		actual := SignatureForLabels(scenario.in, scenario.labels)
 
 		if actual != scenario.out {
 			t.Errorf("%d. expected %d, got %d", i, scenario.out, actual)
@@ -152,17 +128,17 @@ func TestSignatureWithoutLabels(t *testing.T) {
 		{
 			in:     Metric{"name": "garland, briggs", "fear": "love is not enough", "foo": "bar"},
 			labels: map[LabelName]struct{}{"foo": struct{}{}},
-			out:    5799056148416392346,
+			out:    12952432476264840823,
 		},
 		{
 			in:     Metric{"name": "garland, briggs", "fear": "love is not enough"},
 			labels: map[LabelName]struct{}{},
-			out:    5799056148416392346,
+			out:    12952432476264840823,
 		},
 		{
 			in:     Metric{"name": "garland, briggs", "fear": "love is not enough"},
 			labels: nil,
-			out:    5799056148416392346,
+			out:    12952432476264840823,
 		},
 	}
 
@@ -188,21 +164,21 @@ func BenchmarkLabelToSignatureScalar(b *testing.B) {
 }
 
 func BenchmarkLabelToSignatureSingle(b *testing.B) {
-	benchmarkLabelToSignature(b, map[string]string{"first-label": "first-label-value"}, 5146282821936882169)
+	benchmarkLabelToSignature(b, map[string]string{"first-label": "first-label-value"}, 5147259542624943964)
 }
 
 func BenchmarkLabelToSignatureDouble(b *testing.B) {
-	benchmarkLabelToSignature(b, map[string]string{"first-label": "first-label-value", "second-label": "second-label-value"}, 3195800080984914717)
+	benchmarkLabelToSignature(b, map[string]string{"first-label": "first-label-value", "second-label": "second-label-value"}, 18269973311206963528)
 }
 
 func BenchmarkLabelToSignatureTriple(b *testing.B) {
-	benchmarkLabelToSignature(b, map[string]string{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 13843036195897128121)
+	benchmarkLabelToSignature(b, map[string]string{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676)
 }
 
-func benchmarkMetricToFingerprint(b *testing.B, ls LabelSet, e Fingerprint) {
+func benchmarkMetricToFingerprint(b *testing.B, m Metric, e Fingerprint) {
 	for i := 0; i < b.N; i++ {
-		if a := labelSetToFingerprint(ls); a != e {
-			b.Fatalf("expected signature of %d for %s, got %d", e, ls, a)
+		if a := metricToFingerprint(m); a != e {
+			b.Fatalf("expected signature of %d for %s, got %d", e, m, a)
 		}
 	}
 }
@@ -212,42 +188,18 @@ func BenchmarkMetricToFingerprintScalar(b *testing.B) {
 }
 
 func BenchmarkMetricToFingerprintSingle(b *testing.B) {
-	benchmarkMetricToFingerprint(b, LabelSet{"first-label": "first-label-value"}, 5146282821936882169)
+	benchmarkMetricToFingerprint(b, Metric{"first-label": "first-label-value"}, 5147259542624943964)
 }
 
 func BenchmarkMetricToFingerprintDouble(b *testing.B) {
-	benchmarkMetricToFingerprint(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value"}, 3195800080984914717)
+	benchmarkMetricToFingerprint(b, Metric{"first-label": "first-label-value", "second-label": "second-label-value"}, 18269973311206963528)
 }
 
 func BenchmarkMetricToFingerprintTriple(b *testing.B) {
-	benchmarkMetricToFingerprint(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 13843036195897128121)
-}
-
-func benchmarkMetricToFastFingerprint(b *testing.B, ls LabelSet, e Fingerprint) {
-	for i := 0; i < b.N; i++ {
-		if a := labelSetToFastFingerprint(ls); a != e {
-			b.Fatalf("expected signature of %d for %s, got %d", e, ls, a)
-		}
-	}
-}
-
-func BenchmarkMetricToFastFingerprintScalar(b *testing.B) {
-	benchmarkMetricToFastFingerprint(b, nil, 14695981039346656037)
-}
-
-func BenchmarkMetricToFastFingerprintSingle(b *testing.B) {
-	benchmarkMetricToFastFingerprint(b, LabelSet{"first-label": "first-label-value"}, 5147259542624943964)
-}
-
-func BenchmarkMetricToFastFingerprintDouble(b *testing.B) {
-	benchmarkMetricToFastFingerprint(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value"}, 18269973311206963528)
-}
-
-func BenchmarkMetricToFastFingerprintTriple(b *testing.B) {
-	benchmarkMetricToFastFingerprint(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676)
+	benchmarkMetricToFingerprint(b, Metric{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676)
 }
 
-func BenchmarkEmptyLabelSignature(b *testing.B) {
+func TestEmptyLabelSignature(t *testing.T) {
 	input := []map[string]string{nil, {}}
 
 	var ms runtime.MemStats
@@ -262,11 +214,11 @@ func BenchmarkEmptyLabelSignature(b *testing.B) {
 	runtime.ReadMemStats(&ms)
 
 	if got := ms.Alloc; alloc != got {
-		b.Fatal("expected LabelsToSignature with empty labels not to perform allocations")
+		t.Fatal("expected LabelsToSignature with empty labels not to perform allocations")
 	}
 }
 
-func benchmarkMetricToFastFingerprintConc(b *testing.B, ls LabelSet, e Fingerprint, concLevel int) {
+func benchmarkMetricToFingerprintConc(b *testing.B, m Metric, e Fingerprint, concLevel int) {
 	var start, end sync.WaitGroup
 	start.Add(1)
 	end.Add(concLevel)
@@ -275,8 +227,8 @@ func benchmarkMetricToFastFingerprintConc(b *testing.B, ls LabelSet, e Fingerpri
 		go func() {
 			start.Wait()
 			for j := b.N / concLevel; j >= 0; j-- {
-				if a := labelSetToFastFingerprint(ls); a != e {
-					b.Fatalf("expected signature of %d for %s, got %d", e, ls, a)
+				if a := metricToFingerprint(m); a != e {
+					b.Fatalf("expected signature of %d for %s, got %d", e, m, a)
 				}
 			}
 			end.Done()
@@ -287,18 +239,18 @@ func benchmarkMetricToFastFingerprintConc(b *testing.B, ls LabelSet, e Fingerpri
 	end.Wait()
 }
 
-func BenchmarkMetricToFastFingerprintTripleConc1(b *testing.B) {
-	benchmarkMetricToFastFingerprintConc(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 1)
+func BenchmarkMetricToFingerprintTripleConc1(b *testing.B) {
+	benchmarkMetricToFingerprintConc(b, Metric{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 1)
 }
 
-func BenchmarkMetricToFastFingerprintTripleConc2(b *testing.B) {
-	benchmarkMetricToFastFingerprintConc(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 2)
+func BenchmarkMetricToFingerprintTripleConc2(b *testing.B) {
+	benchmarkMetricToFingerprintConc(b, Metric{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 2)
 }
 
-func BenchmarkMetricToFastFingerprintTripleConc4(b *testing.B) {
-	benchmarkMetricToFastFingerprintConc(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 4)
+func BenchmarkMetricToFingerprintTripleConc4(b *testing.B) {
+	benchmarkMetricToFingerprintConc(b, Metric{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 4)
 }
 
-func BenchmarkMetricToFastFingerprintTripleConc8(b *testing.B) {
-	benchmarkMetricToFastFingerprintConc(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 8)
+func BenchmarkMetricToFingerprintTripleConc8(b *testing.B) {
+	benchmarkMetricToFingerprintConc(b, Metric{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 8)
 }

Godeps/_workspace/src/github.com/prometheus/client_golang/model/timestamp.go

+// Copyright 2013 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 model
+
+import (
+	"math"
+	"strconv"
+
+	native_time "time"
+)
+
+// Timestamp is the number of milliseconds since the epoch
+// (1970-01-01 00:00 UTC) excluding leap seconds.
+type Timestamp int64
+
+const (
+	// MinimumTick is the minimum supported time resolution. This has to be
+	// at least native_time.Second in order for the code below to work.
+	MinimumTick = native_time.Millisecond
+	// second is the timestamp duration equivalent to one second.
+	second = int64(native_time.Second / MinimumTick)
+	// The number of nanoseconds per minimum tick.
+	nanosPerTick = int64(MinimumTick / native_time.Nanosecond)
+
+	// Earliest is the earliest timestamp representable. Handy for
+	// initializing a high watermark.
+	Earliest = Timestamp(math.MinInt64)
+	// Latest is the latest timestamp representable. Handy for initializing
+	// a low watermark.
+	Latest = Timestamp(math.MaxInt64)
+)
+
+// Equal reports whether two timestamps represent the same instant.
+func (t Timestamp) Equal(o Timestamp) bool {
+	return t == o
+}
+
+// Before reports whether the timestamp t is before o.
+func (t Timestamp) Before(o Timestamp) bool {
+	return t < o
+}
+
+// After reports whether the timestamp t is after o.
+func (t Timestamp) After(o Timestamp) bool {
+	return t > o
+}
+
+// Add returns the Timestamp t + d.
+func (t Timestamp) Add(d native_time.Duration) Timestamp {
+	return t + Timestamp(d/MinimumTick)
+}
+
+// Sub returns the Duration t - o.
+func (t Timestamp) Sub(o Timestamp) native_time.Duration {
+	return native_time.Duration(t-o) * MinimumTick
+}
+
+// Time returns the time.Time representation of t.
+func (t Timestamp) Time() native_time.Time {
+	return native_time.Unix(int64(t)/second, (int64(t)%second)*nanosPerTick)
+}
+
+// Unix returns t as a Unix time, the number of seconds elapsed
+// since January 1, 1970 UTC.
+func (t Timestamp) Unix() int64 {
+	return int64(t) / second
+}
+
+// UnixNano returns t as a Unix time, the number of nanoseconds elapsed
+// since January 1, 1970 UTC.
+func (t Timestamp) UnixNano() int64 {
+	return int64(t) * nanosPerTick
+}
+
+// String returns a string representation of the timestamp.
+func (t Timestamp) String() string {
+	return strconv.FormatFloat(float64(t)/float64(second), 'f', -1, 64)
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (t Timestamp) MarshalJSON() ([]byte, error) {
+	return []byte(t.String()), nil
+}
+
+// Now returns the current time as a Timestamp.
+func Now() Timestamp {
+	return TimestampFromTime(native_time.Now())
+}
+
+// TimestampFromTime returns the Timestamp equivalent to the time.Time t.
+func TimestampFromTime(t native_time.Time) Timestamp {
+	return TimestampFromUnixNano(t.UnixNano())
+}
+
+// TimestampFromUnix returns the Timestamp equivalent to the Unix timestamp t
+// provided in seconds.
+func TimestampFromUnix(t int64) Timestamp {
+	return Timestamp(t * second)
+}
+
+// TimestampFromUnixNano returns the Timestamp equivalent to the Unix timestamp
+// t provided in nanoseconds.
+func TimestampFromUnixNano(t int64) Timestamp {
+	return Timestamp(t / nanosPerTick)
+}

Godeps/_workspace/src/github.com/prometheus/common/model/time_test.go → Godeps/_workspace/src/github.com/prometheus/client_golang/model/timestamp_test.go

@@ -15,13 +15,13 @@ package model
 
 import (
 	"testing"
-	"time"
+	native_time "time"
 )
 
 func TestComparators(t *testing.T) {
-	t1a := TimeFromUnix(0)
-	t1b := TimeFromUnix(0)
-	t2 := TimeFromUnix(2*second - 1)
+	t1a := TimestampFromUnix(0)
+	t1b := TimestampFromUnix(0)
+	t2 := TimestampFromUnix(2*second - 1)
 
 	if !t1a.Equal(t1b) {
 		t.Fatalf("Expected %s to be equal to %s", t1a, t1b)
@@ -45,21 +45,21 @@ func TestComparators(t *testing.T) {
 	}
 }
 
-func TestTimeConversions(t *testing.T) {
+func TestTimestampConversions(t *testing.T) {
 	unixSecs := int64(1136239445)
 	unixNsecs := int64(123456789)
-	unixNano := unixSecs*1e9 + unixNsecs
+	unixNano := unixSecs*1000000000 + unixNsecs
 
-	t1 := time.Unix(unixSecs, unixNsecs-unixNsecs%nanosPerTick)
-	t2 := time.Unix(unixSecs, unixNsecs)
+	t1 := native_time.Unix(unixSecs, unixNsecs-unixNsecs%nanosPerTick)
+	t2 := native_time.Unix(unixSecs, unixNsecs)
 
-	ts := TimeFromUnixNano(unixNano)
+	ts := TimestampFromUnixNano(unixNano)
 	if !ts.Time().Equal(t1) {
 		t.Fatalf("Expected %s, got %s", t1, ts.Time())
 	}
 
 	// Test available precision.
-	ts = TimeFromUnixNano(t2.UnixNano())
+	ts = TimestampFromTime(t2)
 	if !ts.Time().Equal(t1) {
 		t.Fatalf("Expected %s, got %s", t1, ts.Time())
 	}
@@ -70,10 +70,10 @@ func TestTimeConversions(t *testing.T) {
 }
 
 func TestDuration(t *testing.T) {
-	duration := time.Second + time.Minute + time.Hour
-	goTime := time.Unix(1136239445, 0)
+	duration := native_time.Second + native_time.Minute + native_time.Hour
+	goTime := native_time.Unix(1136239445, 0)
 
-	ts := TimeFromUnix(goTime.Unix())
+	ts := TimestampFromTime(goTime)
 	if !goTime.Add(duration).Equal(ts.Add(duration).Time()) {
 		t.Fatalf("Expected %s to be equal to %s", goTime.Add(duration), ts.Add(duration))
 	}

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/counter.go

@@ -33,7 +33,7 @@ type Counter interface {
 
 	// Set is used to set the Counter to an arbitrary value. It is only used
 	// if you have to transfer a value from an external counter into this
-	// Prometheus metric. Do not use it for regular handling of a
+	// Prometheus metrics. Do not use it for regular handling of a
 	// Prometheus counter (as it can be used to break the contract of
 	// monotonically increasing values).
 	Set(float64)

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/desc.go

@@ -9,20 +9,18 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/golang/protobuf/proto"
+	"github.com/prometheus/client_golang/model"
 
 	dto "github.com/prometheus/client_model/go"
+
+	"github.com/golang/protobuf/proto"
 )
 
 var (
 	metricNameRE = regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_:]*$`)
-	labelNameRE  = regexp.MustCompile("^[a-zA-Z_][a-zA-Z0-9_]*$")
+	labelNameRE  = regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_]*$`)
 )
 
-// reservedLabelPrefix is a prefix which is not legal in user-supplied
-// label names.
-const reservedLabelPrefix = "__"
-
 // Labels represents a collection of label name -> value mappings. This type is
 // commonly used with the With(Labels) and GetMetricWith(Labels) methods of
 // metric vector Collectors, e.g.:
@@ -136,7 +134,7 @@ func NewDesc(fqName, help string, variableLabels []string, constLabels Labels) *
 	for _, val := range labelValues {
 		b.Reset()
 		b.WriteString(val)
-		b.WriteByte(separatorByte)
+		b.WriteByte(model.SeparatorByte)
 		h.Write(b.Bytes())
 	}
 	d.id = h.Sum64()
@@ -147,12 +145,12 @@ func NewDesc(fqName, help string, variableLabels []string, constLabels Labels) *
 	h.Reset()
 	b.Reset()
 	b.WriteString(help)
-	b.WriteByte(separatorByte)
+	b.WriteByte(model.SeparatorByte)
 	h.Write(b.Bytes())
 	for _, labelName := range labelNames {
 		b.Reset()
 		b.WriteString(labelName)
-		b.WriteByte(separatorByte)
+		b.WriteByte(model.SeparatorByte)
 		h.Write(b.Bytes())
 	}
 	d.dimHash = h.Sum64()
@@ -197,5 +195,5 @@ func (d *Desc) String() string {
 
 func checkLabelName(l string) bool {
 	return labelNameRE.MatchString(l) &&
-		!strings.HasPrefix(l, reservedLabelPrefix)
+		!strings.HasPrefix(l, model.ReservedLabelPrefix)
 }

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/doc.go

@@ -61,13 +61,12 @@
 // It also exports some stats about the HTTP usage of the /metrics
 // endpoint. (See the Handler function for more detail.)
 //
-// Two more advanced metric types are the Summary and Histogram.
+// A more advanced metric type is the Summary.
 //
-// In addition to the fundamental metric types Gauge, Counter, Summary, and
-// Histogram, a very important part of the Prometheus data model is the
-// partitioning of samples along dimensions called labels, which results in
-// metric vectors. The fundamental types are GaugeVec, CounterVec, SummaryVec,
-// and HistogramVec.
+// In addition to the fundamental metric types Gauge, Counter, and Summary, a
+// very important part of the Prometheus data model is the partitioning of
+// samples along dimensions called labels, which results in metric vectors. The
+// fundamental types are GaugeVec, CounterVec, and SummaryVec.
 //
 // Those are all the parts needed for basic usage. Detailed documentation and
 // examples are provided below.

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/examples_test.go

@@ -392,9 +392,6 @@ func ExampleSummaryVec() {
 		temps.WithLabelValues("lithobates-catesbeianus").Observe(32 + math.Floor(100*math.Cos(float64(i)*0.11))/10)
 	}
 
-	// Create a Summary without any observations.
-	temps.WithLabelValues("leiopelma-hochstetteri")
-
 	// Just for demonstration, let's check the state of the summary vector
 	// by (ab)using its Collect method and the Write method of its elements
 	// (which is usually only used by Prometheus internally - code like the
@@ -417,26 +414,6 @@ func ExampleSummaryVec() {
 	// Output:
 	// [label: <
 	//   name: "species"
-	//   value: "leiopelma-hochstetteri"
-	// >
-	// summary: <
-	//   sample_count: 0
-	//   sample_sum: 0
-	//   quantile: <
-	//     quantile: 0.5
-	//     value: nan
-	//   >
-	//   quantile: <
-	//     quantile: 0.9
-	//     value: nan
-	//   >
-	//   quantile: <
-	//     quantile: 0.99
-	//     value: nan
-	//   >
-	// >
-	//  label: <
-	//   name: "species"
 	//   value: "lithobates-catesbeianus"
 	// >
 	// summary: <
@@ -478,56 +455,6 @@ func ExampleSummaryVec() {
 	// ]
 }
 
-func ExampleConstSummary() {
-	desc := prometheus.NewDesc(
-		"http_request_duration_seconds",
-		"A summary of the HTTP request durations.",
-		[]string{"code", "method"},
-		prometheus.Labels{"owner": "example"},
-	)
-
-	// Create a constant summary from values we got from a 3rd party telemetry system.
-	s := prometheus.MustNewConstSummary(
-		desc,
-		4711, 403.34,
-		map[float64]float64{0.5: 42.3, 0.9: 323.3},
-		"200", "get",
-	)
-
-	// Just for demonstration, let's check the state of the summary by
-	// (ab)using its Write method (which is usually only used by Prometheus
-	// internally).
-	metric := &dto.Metric{}
-	s.Write(metric)
-	fmt.Println(proto.MarshalTextString(metric))
-
-	// Output:
-	// label: <
-	//   name: "code"
-	//   value: "200"
-	// >
-	// label: <
-	//   name: "method"
-	//   value: "get"
-	// >
-	// label: <
-	//   name: "owner"
-	//   value: "example"
-	// >
-	// summary: <
-	//   sample_count: 4711
-	//   sample_sum: 403.34
-	//   quantile: <
-	//     quantile: 0.5
-	//     value: 42.3
-	//   >
-	//   quantile: <
-	//     quantile: 0.9
-	//     value: 323.3
-	//   >
-	// >
-}
-
 func ExampleHistogram() {
 	temps := prometheus.NewHistogram(prometheus.HistogramOpts{
 		Name:    "pond_temperature_celsius",
@@ -574,64 +501,6 @@ func ExampleHistogram() {
 	// >
 }
 
-func ExampleConstHistogram() {
-	desc := prometheus.NewDesc(
-		"http_request_duration_seconds",
-		"A histogram of the HTTP request durations.",
-		[]string{"code", "method"},
-		prometheus.Labels{"owner": "example"},
-	)
-
-	// Create a constant histogram from values we got from a 3rd party telemetry system.
-	h := prometheus.MustNewConstHistogram(
-		desc,
-		4711, 403.34,
-		map[float64]uint64{25: 121, 50: 2403, 100: 3221, 200: 4233},
-		"200", "get",
-	)
-
-	// Just for demonstration, let's check the state of the histogram by
-	// (ab)using its Write method (which is usually only used by Prometheus
-	// internally).
-	metric := &dto.Metric{}
-	h.Write(metric)
-	fmt.Println(proto.MarshalTextString(metric))
-
-	// Output:
-	// label: <
-	//   name: "code"
-	//   value: "200"
-	// >
-	// label: <
-	//   name: "method"
-	//   value: "get"
-	// >
-	// label: <
-	//   name: "owner"
-	//   value: "example"
-	// >
-	// histogram: <
-	//   sample_count: 4711
-	//   sample_sum: 403.34
-	//   bucket: <
-	//     cumulative_count: 121
-	//     upper_bound: 25
-	//   >
-	//   bucket: <
-	//     cumulative_count: 2403
-	//     upper_bound: 50
-	//   >
-	//   bucket: <
-	//     cumulative_count: 3221
-	//     upper_bound: 100
-	//   >
-	//   bucket: <
-	//     cumulative_count: 4233
-	//     upper_bound: 200
-	//   >
-	// >
-}
-
 func ExamplePushCollectors() {
 	hostname, _ := os.Hostname()
 	completionTime := prometheus.NewGauge(prometheus.GaugeOpts{

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/go_collector.go

@@ -2,13 +2,10 @@ package prometheus
 
 import (
 	"runtime"
-	"runtime/debug"
-	"time"
 )
 
 type goCollector struct {
 	goroutines Gauge
-	gcDesc     *Desc
 }
 
 // NewGoCollector returns a collector which exports metrics about the current
@@ -16,35 +13,19 @@ type goCollector struct {
 func NewGoCollector() *goCollector {
 	return &goCollector{
 		goroutines: NewGauge(GaugeOpts{
-			Name: "go_goroutines",
+			Name: "process_goroutines",
 			Help: "Number of goroutines that currently exist.",
 		}),
-		gcDesc: NewDesc(
-			"go_gc_duration_seconds",
-			"A summary of the GC invocation durations.",
-			nil, nil),
 	}
 }
 
 // Describe returns all descriptions of the collector.
 func (c *goCollector) Describe(ch chan<- *Desc) {
 	ch <- c.goroutines.Desc()
-	ch <- c.gcDesc
 }
 
 // Collect returns the current state of all metrics of the collector.
 func (c *goCollector) Collect(ch chan<- Metric) {
 	c.goroutines.Set(float64(runtime.NumGoroutine()))
 	ch <- c.goroutines
-
-	var stats debug.GCStats
-	stats.PauseQuantiles = make([]time.Duration, 5)
-	debug.ReadGCStats(&stats)
-
-	quantiles := make(map[float64]float64)
-	for idx, pq := range stats.PauseQuantiles[1:] {
-		quantiles[float64(idx+1)/float64(len(stats.PauseQuantiles)-1)] = pq.Seconds()
-	}
-	quantiles[0.0] = stats.PauseQuantiles[0].Seconds()
-	ch <- MustNewConstSummary(c.gcDesc, uint64(stats.NumGC), float64(stats.PauseTotal.Seconds()), quantiles)
 }

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/go_collector_test.go

 package prometheus
 
 import (
-	"runtime"
+	"reflect"
 	"testing"
 	"time"
 
@@ -35,9 +35,6 @@ func TestGoCollector(t *testing.T) {
 			case Gauge:
 				pb := &dto.Metric{}
 				m.Write(pb)
-				if pb.GetGauge() == nil {
-					continue
-				}
 
 				if old == -1 {
 					old = int(pb.GetGauge().GetValue())
@@ -50,71 +47,9 @@ func TestGoCollector(t *testing.T) {
 					t.Errorf("want 1 new goroutine, got %d", diff)
 				}
 
-				// GoCollector performs two sends per call.
-				// On line 27 we need to receive the second send
-				// to shut down cleanly.
-				<-ch
-				return
-			}
-		case <-time.After(1 * time.Second):
-			t.Fatalf("expected collect timed out")
-		}
-	}
-}
-
-func TestGCCollector(t *testing.T) {
-	var (
-		c        = NewGoCollector()
-		ch       = make(chan Metric)
-		waitc    = make(chan struct{})
-		closec   = make(chan struct{})
-		oldGC    uint64
-		oldPause float64
-	)
-	defer close(closec)
-
-	go func() {
-		c.Collect(ch)
-		// force GC
-		runtime.GC()
-		<-waitc
-		c.Collect(ch)
-	}()
-
-	first := true
-	for {
-		select {
-		case metric := <-ch:
-			switch m := metric.(type) {
-			case *constSummary, *value:
-				pb := &dto.Metric{}
-				m.Write(pb)
-				if pb.GetSummary() == nil {
-					continue
-				}
-
-				if len(pb.GetSummary().Quantile) != 5 {
-					t.Errorf("expected 4 buckets, got %d", len(pb.GetSummary().Quantile))
-				}
-				for idx, want := range []float64{0.0, 0.25, 0.5, 0.75, 1.0} {
-					if *pb.GetSummary().Quantile[idx].Quantile != want {
-						t.Errorf("bucket #%d is off, got %f, want %f", idx, *pb.GetSummary().Quantile[idx].Quantile, want)
-					}
-				}
-				if first {
-					first = false
-					oldGC = *pb.GetSummary().SampleCount
-					oldPause = *pb.GetSummary().SampleSum
-					close(waitc)
-					continue
-				}
-				if diff := *pb.GetSummary().SampleCount - oldGC; diff != 1 {
-					t.Errorf("want 1 new garbage collection run, got %d", diff)
-				}
-				if diff := *pb.GetSummary().SampleSum - oldPause; diff <= 0 {
-					t.Errorf("want moar pause, got %f", diff)
-				}
 				return
+			default:
+				t.Errorf("want type Gauge, got %s", reflect.TypeOf(metric))
 			}
 		case <-time.After(1 * time.Second):
 			t.Fatalf("expected collect timed out")

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/histogram.go

@@ -22,6 +22,7 @@ import (
 
 	"github.com/golang/protobuf/proto"
 
+	"github.com/prometheus/client_golang/model"
 	dto "github.com/prometheus/client_model/go"
 )
 
@@ -48,10 +49,6 @@ type Histogram interface {
 	Observe(float64)
 }
 
-// bucketLabel is used for the label that defines the upper bound of a
-// bucket of a histogram ("le" -> "less or equal").
-const bucketLabel = "le"
-
 var (
 	// DefBuckets are the default Histogram buckets. The default buckets are
 	// tailored to broadly measure the response time (in seconds) of a
@@ -60,7 +57,7 @@ var (
 	DefBuckets = []float64{.005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10}
 
 	errBucketLabelNotAllowed = fmt.Errorf(
-		"%q is not allowed as label name in histograms", bucketLabel,
+		"%q is not allowed as label name in histograms", model.BucketLabel,
 	)
 )
 
@@ -150,7 +147,7 @@ type HistogramOpts struct {
 	// element in the slice is the upper inclusive bound of a bucket. The
 	// values must be sorted in strictly increasing order. There is no need
 	// to add a highest bucket with +Inf bound, it will be added
-	// implicitly. The default value is DefBuckets.
+	// implicitly. The default value is DefObjectives.
 	Buckets []float64
 }
 
@@ -174,12 +171,12 @@ func newHistogram(desc *Desc, opts HistogramOpts, labelValues ...string) Histogr
 	}
 
 	for _, n := range desc.variableLabels {
-		if n == bucketLabel {
+		if n == model.BucketLabel {
 			panic(errBucketLabelNotAllowed)
 		}
 	}
 	for _, lp := range desc.constLabelPairs {
-		if lp.GetName() == bucketLabel {
+		if lp.GetName() == model.BucketLabel {
 			panic(errBucketLabelNotAllowed)
 		}
 	}
@@ -216,13 +213,6 @@ func newHistogram(desc *Desc, opts HistogramOpts, labelValues ...string) Histogr
 }
 
 type histogram struct {
-	// sumBits contains the bits of the float64 representing the sum of all
-	// observations. sumBits and count have to go first in the struct to
-	// guarantee alignment for atomic operations.
-	// http://golang.org/pkg/sync/atomic/#pkg-note-BUG
-	sumBits uint64
-	count   uint64
-
 	SelfCollector
 	// Note that there is no mutex required.
 
@@ -232,6 +222,9 @@ type histogram struct {
 	counts      []uint64
 
 	labelPairs []*dto.LabelPair
+
+	sumBits uint64 // The bits of the float64 representing the sum of all observations.
+	count   uint64
 }
 
 func (h *histogram) Desc() *Desc {
@@ -349,102 +342,3 @@ func (m *HistogramVec) WithLabelValues(lvs ...string) Histogram {
 func (m *HistogramVec) With(labels Labels) Histogram {
 	return m.MetricVec.With(labels).(Histogram)
 }
-
-type constHistogram struct {
-	desc       *Desc
-	count      uint64
-	sum        float64
-	buckets    map[float64]uint64
-	labelPairs []*dto.LabelPair
-}
-
-func (h *constHistogram) Desc() *Desc {
-	return h.desc
-}
-
-func (h *constHistogram) Write(out *dto.Metric) error {
-	his := &dto.Histogram{}
-	buckets := make([]*dto.Bucket, 0, len(h.buckets))
-
-	his.SampleCount = proto.Uint64(h.count)
-	his.SampleSum = proto.Float64(h.sum)
-
-	for upperBound, count := range h.buckets {
-		buckets = append(buckets, &dto.Bucket{
-			CumulativeCount: proto.Uint64(count),
-			UpperBound:      proto.Float64(upperBound),
-		})
-	}
-
-	if len(buckets) > 0 {
-		sort.Sort(buckSort(buckets))
-	}
-	his.Bucket = buckets
-
-	out.Histogram = his
-	out.Label = h.labelPairs
-
-	return nil
-}
-
-// NewConstHistogram returns a metric representing a Prometheus histogram with
-// fixed values for the count, sum, and bucket counts. As those parameters
-// cannot be changed, the returned value does not implement the Histogram
-// interface (but only the Metric interface). Users of this package will not
-// have much use for it in regular operations. However, when implementing custom
-// Collectors, it is useful as a throw-away metric that is generated on the fly
-// to send it to Prometheus in the Collect method.
-//
-// buckets is a map of upper bounds to cumulative counts, excluding the +Inf
-// bucket.
-//
-// NewConstHistogram returns an error if the length of labelValues is not
-// consistent with the variable labels in Desc.
-func NewConstHistogram(
-	desc *Desc,
-	count uint64,
-	sum float64,
-	buckets map[float64]uint64,
-	labelValues ...string,
-) (Metric, error) {
-	if len(desc.variableLabels) != len(labelValues) {
-		return nil, errInconsistentCardinality
-	}
-	return &constHistogram{
-		desc:       desc,
-		count:      count,
-		sum:        sum,
-		buckets:    buckets,
-		labelPairs: makeLabelPairs(desc, labelValues),
-	}, nil
-}
-
-// MustNewConstHistogram is a version of NewConstHistogram that panics where
-// NewConstMetric would have returned an error.
-func MustNewConstHistogram(
-	desc *Desc,
-	count uint64,
-	sum float64,
-	buckets map[float64]uint64,
-	labelValues ...string,
-) Metric {
-	m, err := NewConstHistogram(desc, count, sum, buckets, labelValues...)
-	if err != nil {
-		panic(err)
-	}
-	return m
-}
-
-type buckSort []*dto.Bucket
-
-func (s buckSort) Len() int {
-	return len(s)
-}
-
-func (s buckSort) Swap(i, j int) {
-	s[i], s[j] = s[j], s[i]
-}
-
-func (s buckSort) Less(i, j int) bool {
-	return s[i].GetUpperBound() < s[j].GetUpperBound()
-}

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/histogram_test.go

@@ -124,10 +124,6 @@ func BenchmarkHistogramWrite8(b *testing.B) {
 var testBuckets = []float64{-2, -1, -0.5, 0, 0.5, 1, 2, math.Inf(+1)}
 
 func TestHistogramConcurrency(t *testing.T) {
-	if testing.Short() {
-		t.Skip("Skipping test in short mode.")
-	}
-	
 	rand.Seed(42)
 
 	it := func(n uint32) bool {
@@ -202,10 +198,6 @@ func TestHistogramConcurrency(t *testing.T) {
 }
 
 func TestHistogramVecConcurrency(t *testing.T) {
-	if testing.Short() {
-		t.Skip("Skipping test in short mode.")
-	}
-
 	rand.Seed(42)
 
 	objectives := make([]float64, 0, len(DefObjectives))

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/http.go

@@ -14,9 +14,6 @@
 package prometheus
 
 import (
-	"bufio"
-	"io"
-	"net"
 	"net/http"
 	"strconv"
 	"strings"
@@ -144,18 +141,7 @@ func InstrumentHandlerFuncWithOpts(opts SummaryOpts, handlerFunc func(http.Respo
 			urlLen = len(r.URL.String())
 		}
 		go computeApproximateRequestSize(r, out, urlLen)
-
-		_, cn := w.(http.CloseNotifier)
-		_, fl := w.(http.Flusher)
-		_, hj := w.(http.Hijacker)
-		_, rf := w.(io.ReaderFrom)
-		var rw http.ResponseWriter
-		if cn && fl && hj && rf {
-			rw = &fancyResponseWriterDelegator{delegate}
-		} else {
-			rw = delegate
-		}
-		handlerFunc(rw, r)
+		handlerFunc(delegate, r)
 
 		elapsed := float64(time.Since(now)) / float64(time.Microsecond)
 
@@ -192,7 +178,7 @@ type responseWriterDelegator struct {
 
 	handler, method string
 	status          int
-	written         int64
+	written         int
 	wroteHeader     bool
 }
 
@@ -207,32 +193,7 @@ func (r *responseWriterDelegator) Write(b []byte) (int, error) {
 		r.WriteHeader(http.StatusOK)
 	}
 	n, err := r.ResponseWriter.Write(b)
-	r.written += int64(n)
-	return n, err
-}
-
-type fancyResponseWriterDelegator struct {
-	*responseWriterDelegator
-}
-
-func (f *fancyResponseWriterDelegator) CloseNotify() <-chan bool {
-	return f.ResponseWriter.(http.CloseNotifier).CloseNotify()
-}
-
-func (f *fancyResponseWriterDelegator) Flush() {
-	f.ResponseWriter.(http.Flusher).Flush()
-}
-
-func (f *fancyResponseWriterDelegator) Hijack() (net.Conn, *bufio.ReadWriter, error) {
-	return f.ResponseWriter.(http.Hijacker).Hijack()
-}
-
-func (f *fancyResponseWriterDelegator) ReadFrom(r io.Reader) (int64, error) {
-	if !f.wroteHeader {
-		f.WriteHeader(http.StatusOK)
-	}
-	n, err := f.ResponseWriter.(io.ReaderFrom).ReadFrom(r)
-	f.written += n
+	r.written += n
 	return n, err
 }
 

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/metric.go

@@ -19,8 +19,6 @@ import (
 	dto "github.com/prometheus/client_model/go"
 )
 
-const separatorByte byte = 255
-
 // A Metric models a single sample value with its meta data being exported to
 // Prometheus. Implementers of Metric in this package inclued Gauge, Counter,
 // Untyped, and Summary. Users can implement their own Metric types, but that

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/registry.go

@@ -33,10 +33,13 @@ import (
 	"strings"
 	"sync"
 
+	"bitbucket.org/ww/goautoneg"
 	"github.com/golang/protobuf/proto"
-	"github.com/prometheus/common/expfmt"
 
 	dto "github.com/prometheus/client_model/go"
+
+	"github.com/prometheus/client_golang/model"
+	"github.com/prometheus/client_golang/text"
 )
 
 var (
@@ -167,11 +170,6 @@ func Unregister(c Collector) bool {
 // checks are performed, but no further consistency checks (which would require
 // knowledge of a metric descriptor).
 //
-// Sorting concerns: The caller is responsible for sorting the label pairs in
-// each metric. However, the order of metrics will be sorted by the registry as
-// it is required anyway after merging with the metric families collected
-// conventionally.
-//
 // The function must be callable at any time and concurrently.
 func SetMetricFamilyInjectionHook(hook func() []*dto.MetricFamily) {
 	defRegistry.metricFamilyInjectionHook = hook
@@ -343,7 +341,7 @@ func (r *registry) Push(job, instance, pushURL, method string) error {
 	}
 	buf := r.getBuf()
 	defer r.giveBuf(buf)
-	if err := r.writePB(expfmt.NewEncoder(buf, expfmt.FmtProtoDelim)); err != nil {
+	if _, err := r.writePB(buf, text.WriteProtoDelimited); err != nil {
 		if r.panicOnCollectError {
 			panic(err)
 		}
@@ -366,11 +364,11 @@ func (r *registry) Push(job, instance, pushURL, method string) error {
 }
 
 func (r *registry) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	contentType := expfmt.Negotiate(req.Header)
+	enc, contentType := chooseEncoder(req)
 	buf := r.getBuf()
 	defer r.giveBuf(buf)
 	writer, encoding := decorateWriter(req, buf)
-	if err := r.writePB(expfmt.NewEncoder(writer, contentType)); err != nil {
+	if _, err := r.writePB(writer, enc); err != nil {
 		if r.panicOnCollectError {
 			panic(err)
 		}
@@ -381,7 +379,7 @@ func (r *registry) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 		closer.Close()
 	}
 	header := w.Header()
-	header.Set(contentTypeHeader, string(contentType))
+	header.Set(contentTypeHeader, contentType)
 	header.Set(contentLengthHeader, fmt.Sprint(buf.Len()))
 	if encoding != "" {
 		header.Set(contentEncodingHeader, encoding)
@@ -389,7 +387,7 @@ func (r *registry) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	w.Write(buf.Bytes())
 }
 
-func (r *registry) writePB(encoder expfmt.Encoder) error {
+func (r *registry) writePB(w io.Writer, writeEncoded encoder) (int, error) {
 	var metricHashes map[uint64]struct{}
 	if r.collectChecksEnabled {
 		metricHashes = make(map[uint64]struct{})
@@ -441,7 +439,7 @@ func (r *registry) writePB(encoder expfmt.Encoder) error {
 			// TODO: Consider different means of error reporting so
 			// that a single erroneous metric could be skipped
 			// instead of blowing up the whole collection.
-			return fmt.Errorf("error collecting metric %v: %s", desc, err)
+			return 0, fmt.Errorf("error collecting metric %v: %s", desc, err)
 		}
 		switch {
 		case metricFamily.Type != nil:
@@ -457,11 +455,11 @@ func (r *registry) writePB(encoder expfmt.Encoder) error {
 		case dtoMetric.Histogram != nil:
 			metricFamily.Type = dto.MetricType_HISTOGRAM.Enum()
 		default:
-			return fmt.Errorf("empty metric collected: %s", dtoMetric)
+			return 0, fmt.Errorf("empty metric collected: %s", dtoMetric)
 		}
 		if r.collectChecksEnabled {
 			if err := r.checkConsistency(metricFamily, dtoMetric, desc, metricHashes); err != nil {
-				return err
+				return 0, err
 			}
 		}
 		metricFamily.Metric = append(metricFamily.Metric, dtoMetric)
@@ -475,7 +473,7 @@ func (r *registry) writePB(encoder expfmt.Encoder) error {
 				if r.collectChecksEnabled {
 					for _, m := range mf.Metric {
 						if err := r.checkConsistency(mf, m, nil, metricHashes); err != nil {
-							return err
+							return 0, err
 						}
 					}
 				}
@@ -484,7 +482,7 @@ func (r *registry) writePB(encoder expfmt.Encoder) error {
 			for _, m := range mf.Metric {
 				if r.collectChecksEnabled {
 					if err := r.checkConsistency(existingMF, m, nil, metricHashes); err != nil {
-						return err
+						return 0, err
 					}
 				}
 				existingMF.Metric = append(existingMF.Metric, m)
@@ -505,12 +503,15 @@ func (r *registry) writePB(encoder expfmt.Encoder) error {
 	}
 	sort.Strings(names)
 
+	var written int
 	for _, name := range names {
-		if err := encoder.Encode(metricFamiliesByName[name]); err != nil {
-			return err
+		w, err := writeEncoded(w, metricFamiliesByName[name])
+		written += w
+		if err != nil {
+			return written, err
 		}
 	}
-	return nil
+	return written, nil
 }
 
 func (r *registry) checkConsistency(metricFamily *dto.MetricFamily, dtoMetric *dto.Metric, desc *Desc, metricHashes map[uint64]struct{}) error {
@@ -519,11 +520,10 @@ func (r *registry) checkConsistency(metricFamily *dto.MetricFamily, dtoMetric *d
 	if metricFamily.GetType() == dto.MetricType_GAUGE && dtoMetric.Gauge == nil ||
 		metricFamily.GetType() == dto.MetricType_COUNTER && dtoMetric.Counter == nil ||
 		metricFamily.GetType() == dto.MetricType_SUMMARY && dtoMetric.Summary == nil ||
-		metricFamily.GetType() == dto.MetricType_HISTOGRAM && dtoMetric.Histogram == nil ||
 		metricFamily.GetType() == dto.MetricType_UNTYPED && dtoMetric.Untyped == nil {
 		return fmt.Errorf(
-			"collected metric %s %s is not a %s",
-			metricFamily.GetName(), dtoMetric, metricFamily.GetType(),
+			"collected metric %q is not a %s",
+			dtoMetric, metricFamily.Type,
 		)
 	}
 
@@ -531,24 +531,19 @@ func (r *registry) checkConsistency(metricFamily *dto.MetricFamily, dtoMetric *d
 	h := fnv.New64a()
 	var buf bytes.Buffer
 	buf.WriteString(metricFamily.GetName())
-	buf.WriteByte(separatorByte)
+	buf.WriteByte(model.SeparatorByte)
 	h.Write(buf.Bytes())
-	// Make sure label pairs are sorted. We depend on it for the consistency
-	// check. Label pairs must be sorted by contract. But the point of this
-	// method is to check for contract violations. So we better do the sort
-	// now.
-	sort.Sort(LabelPairSorter(dtoMetric.Label))
 	for _, lp := range dtoMetric.Label {
 		buf.Reset()
 		buf.WriteString(lp.GetValue())
-		buf.WriteByte(separatorByte)
+		buf.WriteByte(model.SeparatorByte)
 		h.Write(buf.Bytes())
 	}
 	metricHash := h.Sum64()
 	if _, exists := metricHashes[metricHash]; exists {
 		return fmt.Errorf(
-			"collected metric %s %s was collected before with the same name and label values",
-			metricFamily.GetName(), dtoMetric,
+			"collected metric %q was collected before with the same name and label values",
+			dtoMetric,
 		)
 	}
 	metricHashes[metricHash] = struct{}{}
@@ -560,14 +555,14 @@ func (r *registry) checkConsistency(metricFamily *dto.MetricFamily, dtoMetric *d
 	// Desc consistency with metric family.
 	if metricFamily.GetName() != desc.fqName {
 		return fmt.Errorf(
-			"collected metric %s %s has name %q but should have %q",
-			metricFamily.GetName(), dtoMetric, metricFamily.GetName(), desc.fqName,
+			"collected metric %q has name %q but should have %q",
+			dtoMetric, metricFamily.GetName(), desc.fqName,
 		)
 	}
 	if metricFamily.GetHelp() != desc.help {
 		return fmt.Errorf(
-			"collected metric %s %s has help %q but should have %q",
-			metricFamily.GetName(), dtoMetric, metricFamily.GetHelp(), desc.help,
+			"collected metric %q has help %q but should have %q",
+			dtoMetric, metricFamily.GetHelp(), desc.help,
 		)
 	}
 
@@ -581,8 +576,8 @@ func (r *registry) checkConsistency(metricFamily *dto.MetricFamily, dtoMetric *d
 	}
 	if len(lpsFromDesc) != len(dtoMetric.Label) {
 		return fmt.Errorf(
-			"labels in collected metric %s %s are inconsistent with descriptor %s",
-			metricFamily.GetName(), dtoMetric, desc,
+			"labels in collected metric %q are inconsistent with descriptor %s",
+			dtoMetric, desc,
 		)
 	}
 	sort.Sort(LabelPairSorter(lpsFromDesc))
@@ -591,8 +586,8 @@ func (r *registry) checkConsistency(metricFamily *dto.MetricFamily, dtoMetric *d
 		if lpFromDesc.GetName() != lpFromMetric.GetName() ||
 			lpFromDesc.Value != nil && lpFromDesc.GetValue() != lpFromMetric.GetValue() {
 			return fmt.Errorf(
-				"labels in collected metric %s %s are inconsistent with descriptor %s",
-				metricFamily.GetName(), dtoMetric, desc,
+				"labels in collected metric %q are inconsistent with descriptor %s",
+				dtoMetric, desc,
 			)
 		}
 	}
@@ -602,10 +597,7 @@ func (r *registry) checkConsistency(metricFamily *dto.MetricFamily, dtoMetric *d
 
 	// Is the desc registered?
 	if _, exist := r.descIDs[desc.id]; !exist {
-		return fmt.Errorf(
-			"collected metric %s %s with unregistered descriptor %s",
-			metricFamily.GetName(), dtoMetric, desc,
-		)
+		return fmt.Errorf("collected metric %q with unregistered descriptor %s", dtoMetric, desc)
 	}
 
 	return nil
@@ -680,6 +672,34 @@ func newDefaultRegistry() *registry {
 	return r
 }
 
+func chooseEncoder(req *http.Request) (encoder, string) {
+	accepts := goautoneg.ParseAccept(req.Header.Get(acceptHeader))
+	for _, accept := range accepts {
+		switch {
+		case accept.Type == "application" &&
+			accept.SubType == "vnd.google.protobuf" &&
+			accept.Params["proto"] == "io.prometheus.client.MetricFamily":
+			switch accept.Params["encoding"] {
+			case "delimited":
+				return text.WriteProtoDelimited, DelimitedTelemetryContentType
+			case "text":
+				return text.WriteProtoText, ProtoTextTelemetryContentType
+			case "compact-text":
+				return text.WriteProtoCompactText, ProtoCompactTextTelemetryContentType
+			default:
+				continue
+			}
+		case accept.Type == "text" &&
+			accept.SubType == "plain" &&
+			(accept.Params["version"] == "0.0.4" || accept.Params["version"] == ""):
+			return text.MetricFamilyToText, TextTelemetryContentType
+		default:
+			continue
+		}
+	}
+	return text.MetricFamilyToText, TextTelemetryContentType
+}
+
 // decorateWriter wraps a writer to handle gzip compression if requested.  It
 // returns the decorated writer and the appropriate "Content-Encoding" header
 // (which is empty if no compression is enabled).

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/registry_test.go

@@ -69,13 +69,13 @@ func testHandler(t testing.TB) {
 			{
 				Label: []*dto.LabelPair{
 					{
-						Name:  proto.String("externalconstname"),
-						Value: proto.String("externalconstvalue"),
-					},
-					{
 						Name:  proto.String("externallabelname"),
 						Value: proto.String("externalval1"),
 					},
+					{
+						Name:  proto.String("externalconstname"),
+						Value: proto.String("externalconstvalue"),
+					},
 				},
 				Counter: &dto.Counter{
 					Value: proto.Float64(1),
@@ -100,27 +100,27 @@ func testHandler(t testing.TB) {
 	externalMetricFamilyAsBytes := externalBuf.Bytes()
 	externalMetricFamilyAsText := []byte(`# HELP externalname externaldocstring
 # TYPE externalname counter
-externalname{externalconstname="externalconstvalue",externallabelname="externalval1"} 1
+externalname{externallabelname="externalval1",externalconstname="externalconstvalue"} 1
 `)
 	externalMetricFamilyAsProtoText := []byte(`name: "externalname"
 help: "externaldocstring"
 type: COUNTER
 metric: <
   label: <
-    name: "externalconstname"
-    value: "externalconstvalue"
-  >
-  label: <
     name: "externallabelname"
     value: "externalval1"
   >
+  label: <
+    name: "externalconstname"
+    value: "externalconstvalue"
+  >
   counter: <
     value: 1
   >
 >
 
 `)
-	externalMetricFamilyAsProtoCompactText := []byte(`name:"externalname" help:"externaldocstring" type:COUNTER metric:<label:<name:"externalconstname" value:"externalconstvalue" > label:<name:"externallabelname" value:"externalval1" > counter:<value:1 > > 
+	externalMetricFamilyAsProtoCompactText := []byte(`name:"externalname" help:"externaldocstring" type:COUNTER metric:<label:<name:"externallabelname" value:"externalval1" > label:<name:"externalconstname" value:"externalconstvalue" > counter:<value:1 > > 
 `)
 
 	expectedMetricFamily := &dto.MetricFamily{

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/summary.go

@@ -25,11 +25,9 @@ import (
 	"github.com/golang/protobuf/proto"
 
 	dto "github.com/prometheus/client_model/go"
-)
 
-// quantileLabel is used for the label that defines the quantile in a
-// summary.
-const quantileLabel = "quantile"
+	"github.com/prometheus/client_golang/model"
+)
 
 // A Summary captures individual observations from an event or sample stream and
 // summarizes them in a manner similar to traditional summary statistics: 1. sum
@@ -59,7 +57,7 @@ var (
 	DefObjectives = map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001}
 
 	errQuantileLabelNotAllowed = fmt.Errorf(
-		"%q is not allowed as label name in summaries", quantileLabel,
+		"%q is not allowed as label name in summaries", model.QuantileLabel,
 	)
 )
 
@@ -114,9 +112,7 @@ type SummaryOpts struct {
 	ConstLabels Labels
 
 	// Objectives defines the quantile rank estimates with their respective
-	// absolute error. If Objectives[q] = e, then the value reported
-	// for q will be the φ-quantile value for some φ between q-e and q+e.
-	// The default value is DefObjectives.
+	// absolute error. The default value is DefObjectives.
 	Objectives map[float64]float64
 
 	// MaxAge defines the duration for which an observation stays relevant
@@ -174,12 +170,12 @@ func newSummary(desc *Desc, opts SummaryOpts, labelValues ...string) Summary {
 	}
 
 	for _, n := range desc.variableLabels {
-		if n == quantileLabel {
+		if n == model.QuantileLabel {
 			panic(errQuantileLabelNotAllowed)
 		}
 	}
 	for _, lp := range desc.constLabelPairs {
-		if lp.GetName() == quantileLabel {
+		if lp.GetName() == model.QuantileLabel {
 			panic(errQuantileLabelNotAllowed)
 		}
 	}
@@ -452,89 +448,3 @@ func (m *SummaryVec) WithLabelValues(lvs ...string) Summary {
 func (m *SummaryVec) With(labels Labels) Summary {
 	return m.MetricVec.With(labels).(Summary)
 }
-
-type constSummary struct {
-	desc       *Desc
-	count      uint64
-	sum        float64
-	quantiles  map[float64]float64
-	labelPairs []*dto.LabelPair
-}
-
-func (s *constSummary) Desc() *Desc {
-	return s.desc
-}
-
-func (s *constSummary) Write(out *dto.Metric) error {
-	sum := &dto.Summary{}
-	qs := make([]*dto.Quantile, 0, len(s.quantiles))
-
-	sum.SampleCount = proto.Uint64(s.count)
-	sum.SampleSum = proto.Float64(s.sum)
-
-	for rank, q := range s.quantiles {
-		qs = append(qs, &dto.Quantile{
-			Quantile: proto.Float64(rank),
-			Value:    proto.Float64(q),
-		})
-	}
-
-	if len(qs) > 0 {
-		sort.Sort(quantSort(qs))
-	}
-	sum.Quantile = qs
-
-	out.Summary = sum
-	out.Label = s.labelPairs
-
-	return nil
-}
-
-// NewConstSummary returns a metric representing a Prometheus summary with fixed
-// values for the count, sum, and quantiles. As those parameters cannot be
-// changed, the returned value does not implement the Summary interface (but
-// only the Metric interface). Users of this package will not have much use for
-// it in regular operations. However, when implementing custom Collectors, it is
-// useful as a throw-away metric that is generated on the fly to send it to
-// Prometheus in the Collect method.
-//
-// quantiles maps ranks to quantile values. For example, a median latency of
-// 0.23s and a 99th percentile latency of 0.56s would be expressed as:
-//     map[float64]float64{0.5: 0.23, 0.99: 0.56}
-//
-// NewConstSummary returns an error if the length of labelValues is not
-// consistent with the variable labels in Desc.
-func NewConstSummary(
-	desc *Desc,
-	count uint64,
-	sum float64,
-	quantiles map[float64]float64,
-	labelValues ...string,
-) (Metric, error) {
-	if len(desc.variableLabels) != len(labelValues) {
-		return nil, errInconsistentCardinality
-	}
-	return &constSummary{
-		desc:       desc,
-		count:      count,
-		sum:        sum,
-		quantiles:  quantiles,
-		labelPairs: makeLabelPairs(desc, labelValues),
-	}, nil
-}
-
-// MustNewConstSummary is a version of NewConstSummary that panics where
-// NewConstMetric would have returned an error.
-func MustNewConstSummary(
-	desc *Desc,
-	count uint64,
-	sum float64,
-	quantiles map[float64]float64,
-	labelValues ...string,
-) Metric {
-	m, err := NewConstSummary(desc, count, sum, quantiles, labelValues...)
-	if err != nil {
-		panic(err)
-	}
-	return m
-}

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/untyped.go

@@ -21,7 +21,7 @@ import "hash/fnv"
 // An Untyped metric works the same as a Gauge. The only difference is that to
 // no type information is implied.
 //
-// To create Untyped instances, use NewUntyped.
+// To create Gauge instances, use NewUntyped.
 type Untyped interface {
 	Metric
 	Collector

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/value.go

@@ -43,15 +43,11 @@ var errInconsistentCardinality = errors.New("inconsistent label cardinality")
 // ValueType. This is a low-level building block used by the library to back the
 // implementations of Counter, Gauge, and Untyped.
 type value struct {
-	// valBits containst the bits of the represented float64 value. It has
-	// to go first in the struct to guarantee alignment for atomic
-	// operations.  http://golang.org/pkg/sync/atomic/#pkg-note-BUG
-	valBits uint64
-
 	SelfCollector
 
 	desc       *Desc
 	valType    ValueType
+	valBits    uint64 // These are the bits of the represented float64 value.
 	labelPairs []*dto.LabelPair
 }
 

Godeps/_workspace/src/github.com/prometheus/client_golang/prometheus/vec.go

@@ -58,11 +58,6 @@ func (m *MetricVec) Collect(ch chan<- Metric) {
 // GetMetricWithLabelValues returns the Metric for the given slice of label
 // values (same order as the VariableLabels in Desc). If that combination of
 // label values is accessed for the first time, a new Metric is created.
-//
-// It is possible to call this method without using the returned Metric to only
-// create the new Metric but leave it at its start value (e.g. a Summary or
-// Histogram without any observations). See also the SummaryVec example.
-//
 // Keeping the Metric for later use is possible (and should be considered if
 // performance is critical), but keep in mind that Reset, DeleteLabelValues and
 // Delete can be used to delete the Metric from the MetricVec. In that case, the
@@ -92,9 +87,8 @@ func (m *MetricVec) GetMetricWithLabelValues(lvs ...string) (Metric, error) {
 
 // GetMetricWith returns the Metric for the given Labels map (the label names
 // must match those of the VariableLabels in Desc). If that label map is
-// accessed for the first time, a new Metric is created. Implications of
-// creating a Metric without using it and keeping the Metric for later use are
-// the same as for GetMetricWithLabelValues.
+// accessed for the first time, a new Metric is created. Implications of keeping
+// the Metric are the same as for GetMetricWithLabelValues.
 //
 // An error is returned if the number and names of the Labels are inconsistent
 // with those of the VariableLabels in Desc.

Godeps/_workspace/src/github.com/prometheus/common/expfmt/bench_test.go → Godeps/_workspace/src/github.com/prometheus/client_golang/text/bench_test.go

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package expfmt
+package text
 
 import (
 	"bytes"
@@ -19,14 +19,11 @@ import (
 	"io"
 	"io/ioutil"
 	"testing"
+	dto "github.com/prometheus/client_model/go"
 
 	"github.com/matttproud/golang_protobuf_extensions/pbutil"
-
-	dto "github.com/prometheus/client_model/go"
 )
 
-var parser TextParser
-
 // Benchmarks to show how much penalty text format parsing actually inflicts.
 //
 // Example results on Linux 3.13.0, Intel(R) Core(TM) i7-4700MQ CPU @ 2.40GHz, go1.4.

Godeps/_workspace/src/github.com/prometheus/common/expfmt/text_create.go → Godeps/_workspace/src/github.com/prometheus/client_golang/text/create.go

@@ -11,7 +11,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package expfmt
+// Package text contains helper functions to parse and create text-based
+// exchange formats. The package currently supports (only) version 0.0.4 of the
+// exchange format. Should other versions be supported in the future, some
+// versioning scheme has to be applied. Possibilities include separate packages
+// or separate functions. The best way depends on the nature of future changes,
+// which is the reason why no versioning scheme has been applied prematurely
+// here.
+package text
 
 import (
 	"bytes"
@@ -20,8 +27,8 @@ import (
 	"math"
 	"strings"
 
+	"github.com/prometheus/client_golang/model"
 	dto "github.com/prometheus/client_model/go"
-	"github.com/prometheus/common/model"
 )
 
 // MetricFamilyToText converts a MetricFamily proto message into text format and
@@ -72,7 +79,7 @@ func MetricFamilyToText(out io.Writer, in *dto.MetricFamily) (int, error) {
 		case dto.MetricType_COUNTER:
 			if metric.Counter == nil {
 				return written, fmt.Errorf(
-					"expected counter in metric %s %s", name, metric,
+					"expected counter in metric %s", metric,
 				)
 			}
 			n, err = writeSample(
@@ -83,7 +90,7 @@ func MetricFamilyToText(out io.Writer, in *dto.MetricFamily) (int, error) {
 		case dto.MetricType_GAUGE:
 			if metric.Gauge == nil {
 				return written, fmt.Errorf(
-					"expected gauge in metric %s %s", name, metric,
+					"expected gauge in metric %s", metric,
 				)
 			}
 			n, err = writeSample(
@@ -94,7 +101,7 @@ func MetricFamilyToText(out io.Writer, in *dto.MetricFamily) (int, error) {
 		case dto.MetricType_UNTYPED:
 			if metric.Untyped == nil {
 				return written, fmt.Errorf(
-					"expected untyped in metric %s %s", name, metric,
+					"expected untyped in metric %s", metric,
 				)
 			}
 			n, err = writeSample(
@@ -105,7 +112,7 @@ func MetricFamilyToText(out io.Writer, in *dto.MetricFamily) (int, error) {
 		case dto.MetricType_SUMMARY:
 			if metric.Summary == nil {
 				return written, fmt.Errorf(
-					"expected summary in metric %s %s", name, metric,
+					"expected summary in metric %s", metric,
 				)
 			}
 			for _, q := range metric.Summary.Quantile {
@@ -137,7 +144,7 @@ func MetricFamilyToText(out io.Writer, in *dto.MetricFamily) (int, error) {
 		case dto.MetricType_HISTOGRAM:
 			if metric.Histogram == nil {
 				return written, fmt.Errorf(
-					"expected histogram in metric %s %s", name, metric,
+					"expected summary in metric %s", metric,
 				)
 			}
 			infSeen := false
@@ -184,7 +191,7 @@ func MetricFamilyToText(out io.Writer, in *dto.MetricFamily) (int, error) {
 			)
 		default:
 			return written, fmt.Errorf(
-				"unexpected type in metric %s %s", name, metric,
+				"unexpected type in metric %s", metric,
 			)
 		}
 		written += n

Godeps/_workspace/src/github.com/prometheus/common/expfmt/text_create_test.go → Godeps/_workspace/src/github.com/prometheus/client_golang/text/create_test.go

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package expfmt
+package text
 
 import (
 	"bytes"
@@ -20,7 +20,6 @@ import (
 	"testing"
 
 	"github.com/golang/protobuf/proto"
-
 	dto "github.com/prometheus/client_model/go"
 )
 

Godeps/_workspace/src/github.com/prometheus/common/expfmt/text_parse_test.go → Godeps/_workspace/src/github.com/prometheus/client_golang/text/parse_test.go

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package expfmt
+package text
 
 import (
 	"math"
@@ -22,7 +22,9 @@ import (
 	dto "github.com/prometheus/client_model/go"
 )
 
-func testTextParse(t testing.TB) {
+var parser Parser
+
+func testParse(t testing.TB) {
 	var scenarios = []struct {
 		in  string
 		out []*dto.MetricFamily
@@ -417,17 +419,17 @@ request_duration_microseconds_count 2693
 	}
 }
 
-func TestTextParse(t *testing.T) {
-	testTextParse(t)
+func TestParse(t *testing.T) {
+	testParse(t)
 }
 
-func BenchmarkTextParse(b *testing.B) {
+func BenchmarkParse(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		testTextParse(b)
+		testParse(b)
 	}
 }
 
-func testTextParseError(t testing.TB) {
+func testParseError(t testing.TB) {
 	var scenarios = []struct {
 		in  string
 		err string
@@ -575,12 +577,12 @@ metric_bucket{le="bla"} 3.14
 
 }
 
-func TestTextParseError(t *testing.T) {
-	testTextParseError(t)
+func TestParseError(t *testing.T) {
+	testParseError(t)
 }
 
 func BenchmarkParseError(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		testTextParseError(b)
+		testParseError(b)
 	}
 }

Godeps/_workspace/src/github.com/prometheus/client_golang/text/proto.go

+// Copyright 2014 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 text
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/matttproud/golang_protobuf_extensions/pbutil"
+
+	dto "github.com/prometheus/client_model/go"
+)
+
+// WriteProtoDelimited writes the MetricFamily to the writer in delimited
+// protobuf format and returns the number of bytes written and any error
+// encountered.
+func WriteProtoDelimited(w io.Writer, p *dto.MetricFamily) (int, error) {
+	return pbutil.WriteDelimited(w, p)
+}
+
+// WriteProtoText writes the MetricFamily to the writer in text format and
+// returns the number of bytes written and any error encountered.
+func WriteProtoText(w io.Writer, p *dto.MetricFamily) (int, error) {
+	return fmt.Fprintf(w, "%s\n", proto.MarshalTextString(p))
+}
+
+// WriteProtoCompactText writes the MetricFamily to the writer in compact text
+// format and returns the number of bytes written and any error encountered.
+func WriteProtoCompactText(w io.Writer, p *dto.MetricFamily) (int, error) {
+	return fmt.Fprintf(w, "%s\n", p)
+}

Godeps/_workspace/src/github.com/prometheus/common/expfmt/testdata/text → Godeps/_workspace/src/github.com/prometheus/client_golang/text/testdata/text

@@ -175,9 +175,9 @@ http_response_size_bytes_count{handler="prometheus"} 119
 # HELP process_cpu_seconds_total Total user and system CPU time spent in seconds.
 # TYPE process_cpu_seconds_total counter
 process_cpu_seconds_total 0.55
-# HELP go_goroutines Number of goroutines that currently exist.
-# TYPE go_goroutines gauge
-go_goroutines 70
+# HELP process_goroutines Number of goroutines that currently exist.
+# TYPE process_goroutines gauge
+process_goroutines 70
 # HELP process_max_fds Maximum number of open file descriptors.
 # TYPE process_max_fds gauge
 process_max_fds 8192

Godeps/_workspace/src/github.com/prometheus/common/expfmt/decode_test.go

-// Copyright 2015 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 expfmt
-
-import (
-	"errors"
-	"io"
-	"net/http"
-	"reflect"
-	"sort"
-	"strings"
-	"testing"
-
-	"github.com/prometheus/common/model"
-)
-
-func TestTextDecoder(t *testing.T) {
-	var (
-		ts = model.Now()
-		in = `
-# Only a quite simple scenario with two metric families.
-# More complicated tests of the parser itself can be found in the text package.
-# TYPE mf2 counter
-mf2 3
-mf1{label="value1"} -3.14 123456
-mf1{label="value2"} 42
-mf2 4
-`
-		out = model.Vector{
-			&model.Sample{
-				Metric: model.Metric{
-					model.MetricNameLabel: "mf1",
-					"label":               "value1",
-				},
-				Value:     -3.14,
-				Timestamp: 123456,
-			},
-			&model.Sample{
-				Metric: model.Metric{
-					model.MetricNameLabel: "mf1",
-					"label":               "value2",
-				},
-				Value:     42,
-				Timestamp: ts,
-			},
-			&model.Sample{
-				Metric: model.Metric{
-					model.MetricNameLabel: "mf2",
-				},
-				Value:     3,
-				Timestamp: ts,
-			},
-			&model.Sample{
-				Metric: model.Metric{
-					model.MetricNameLabel: "mf2",
-				},
-				Value:     4,
-				Timestamp: ts,
-			},
-		}
-	)
-
-	dec := &SampleDecoder{
-		Dec: &textDecoder{r: strings.NewReader(in)},
-		Opts: &DecodeOptions{
-			Timestamp: ts,
-		},
-	}
-	var all model.Vector
-	for {
-		var smpls model.Vector
-		err := dec.Decode(&smpls)
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			t.Fatal(err)
-		}
-		all = append(all, smpls...)
-	}
-	sort.Sort(all)
-	sort.Sort(out)
-	if !reflect.DeepEqual(all, out) {
-		t.Fatalf("output does not match")
-	}
-}
-
-func TestProtoDecoder(t *testing.T) {
-
-	var testTime = model.Now()
-
-	scenarios := []struct {
-		in       string
-		expected model.Vector
-	}{
-		{
-			in: "",
-		},
-		{
-			in: "\x8f\x01\n\rrequest_count\x12\x12Number of requests\x18\x00\"0\n#\n\x0fsome_label_name\x12\x10some_label_value\x1a\t\t\x00\x00\x00\x00\x00\x00E\xc0\"6\n)\n\x12another_label_name\x12\x13another_label_value\x1a\t\t\x00\x00\x00\x00\x00\x00U@",
-			expected: model.Vector{
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_count",
-						"some_label_name":     "some_label_value",
-					},
-					Value:     -42,
-					Timestamp: testTime,
-				},
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_count",
-						"another_label_name":  "another_label_value",
-					},
-					Value:     84,
-					Timestamp: testTime,
-				},
-			},
-		},
-		{
-			in: "\xb9\x01\n\rrequest_count\x12\x12Number of requests\x18\x02\"O\n#\n\x0fsome_label_name\x12\x10some_label_value\"(\x1a\x12\t\xaeG\xe1z\x14\xae\xef?\x11\x00\x00\x00\x00\x00\x00E\xc0\x1a\x12\t+\x87\x16\xd9\xce\xf7\xef?\x11\x00\x00\x00\x00\x00\x00U\xc0\"A\n)\n\x12another_label_name\x12\x13another_label_value\"\x14\x1a\x12\t\x00\x00\x00\x00\x00\x00\xe0?\x11\x00\x00\x00\x00\x00\x00$@",
-			expected: model.Vector{
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_count",
-						"some_label_name":     "some_label_value",
-						"quantile":            "0.99",
-					},
-					Value:     -42,
-					Timestamp: testTime,
-				},
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_count",
-						"some_label_name":     "some_label_value",
-						"quantile":            "0.999",
-					},
-					Value:     -84,
-					Timestamp: testTime,
-				},
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_count",
-						"another_label_name":  "another_label_value",
-						"quantile":            "0.5",
-					},
-					Value:     10,
-					Timestamp: testTime,
-				},
-			},
-		},
-		{
-			in: "\x8d\x01\n\x1drequest_duration_microseconds\x12\x15The response latency.\x18\x04\"S:Q\b\x85\x15\x11\xcd\xcc\xccL\x8f\xcb:A\x1a\v\b{\x11\x00\x00\x00\x00\x00\x00Y@\x1a\f\b\x9c\x03\x11\x00\x00\x00\x00\x00\x00^@\x1a\f\b\xd0\x04\x11\x00\x00\x00\x00\x00\x00b@\x1a\f\b\xf4\v\x11\x9a\x99\x99\x99\x99\x99e@\x1a\f\b\x85\x15\x11\x00\x00\x00\x00\x00\x00\xf0\u007f",
-			expected: model.Vector{
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_duration_microseconds_bucket",
-						"le": "100",
-					},
-					Value:     123,
-					Timestamp: testTime,
-				},
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_duration_microseconds_bucket",
-						"le": "120",
-					},
-					Value:     412,
-					Timestamp: testTime,
-				},
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_duration_microseconds_bucket",
-						"le": "144",
-					},
-					Value:     592,
-					Timestamp: testTime,
-				},
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_duration_microseconds_bucket",
-						"le": "172.8",
-					},
-					Value:     1524,
-					Timestamp: testTime,
-				},
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_duration_microseconds_bucket",
-						"le": "+Inf",
-					},
-					Value:     2693,
-					Timestamp: testTime,
-				},
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_duration_microseconds_sum",
-					},
-					Value:     1756047.3,
-					Timestamp: testTime,
-				},
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_duration_microseconds_count",
-					},
-					Value:     2693,
-					Timestamp: testTime,
-				},
-			},
-		},
-		{
-			// The metric type is unset in this protobuf, which needs to be handled
-			// correctly by the decoder.
-			in: "\x1c\n\rrequest_count\"\v\x1a\t\t\x00\x00\x00\x00\x00\x00\xf0?",
-			expected: model.Vector{
-				&model.Sample{
-					Metric: model.Metric{
-						model.MetricNameLabel: "request_count",
-					},
-					Value:     1,
-					Timestamp: testTime,
-				},
-			},
-		},
-	}
-
-	for _, scenario := range scenarios {
-		dec := &SampleDecoder{
-			Dec: &protoDecoder{r: strings.NewReader(scenario.in)},
-			Opts: &DecodeOptions{
-				Timestamp: testTime,
-			},
-		}
-
-		var all model.Vector
-		for {
-			var smpls model.Vector
-			err := dec.Decode(&smpls)
-			if err == io.EOF {
-				break
-			}
-			if err != nil {
-				t.Fatal(err)
-			}
-			all = append(all, smpls...)
-		}
-		sort.Sort(all)
-		sort.Sort(scenario.expected)
-		if !reflect.DeepEqual(all, scenario.expected) {
-			t.Fatalf("output does not match")
-		}
-	}
-}
-
-func testDiscriminatorHTTPHeader(t testing.TB) {
-	var scenarios = []struct {
-		input  map[string]string
-		output Decoder
-		err    error
-	}{
-		{
-			input:  map[string]string{"Content-Type": `application/vnd.google.protobuf; proto="io.prometheus.client.MetricFamily"; encoding="delimited"`},
-			output: &protoDecoder{},
-			err:    nil,
-		},
-		{
-			input:  map[string]string{"Content-Type": `application/vnd.google.protobuf; proto="illegal"; encoding="delimited"`},
-			output: nil,
-			err:    errors.New("unrecognized protocol message illegal"),
-		},
-		{
-			input:  map[string]string{"Content-Type": `application/vnd.google.protobuf; proto="io.prometheus.client.MetricFamily"; encoding="illegal"`},
-			output: nil,
-			err:    errors.New("unsupported encoding illegal"),
-		},
-		{
-			input:  map[string]string{"Content-Type": `text/plain; version=0.0.4`},
-			output: &textDecoder{},
-			err:    nil,
-		},
-		{
-			input:  map[string]string{"Content-Type": `text/plain`},
-			output: &textDecoder{},
-			err:    nil,
-		},
-		{
-			input:  map[string]string{"Content-Type": `text/plain; version=0.0.3`},
-			output: nil,
-			err:    errors.New("unrecognized protocol version 0.0.3"),
-		},
-	}
-
-	for i, scenario := range scenarios {
-		var header http.Header
-
-		if len(scenario.input) > 0 {
-			header = http.Header{}
-		}
-
-		for key, value := range scenario.input {
-			header.Add(key, value)
-		}
-
-		actual, err := NewDecoder(nil, header)
-
-		if scenario.err != err {
-			if scenario.err != nil && err != nil {
-				if scenario.err.Error() != err.Error() {
-					t.Errorf("%d. expected %s, got %s", i, scenario.err, err)
-				}
-			} else if scenario.err != nil || err != nil {
-				t.Errorf("%d. expected %s, got %s", i, scenario.err, err)
-			}
-		}
-
-		if !reflect.DeepEqual(scenario.output, actual) {
-			t.Errorf("%d. expected %s, got %s", i, scenario.output, actual)
-		}
-	}
-}
-
-func TestDiscriminatorHTTPHeader(t *testing.T) {
-	testDiscriminatorHTTPHeader(t)
-}
-
-func BenchmarkDiscriminatorHTTPHeader(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		testDiscriminatorHTTPHeader(b)
-	}
-}