Merge pull request #1152 from jessicalins/update-to-custom-reg

Update examples to use custom registry

examples/random/main.go

@@ -30,6 +30,39 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
 
+type metrics struct {
+	rpcDurations          *prometheus.SummaryVec
+	rpcDurationsHistogram prometheus.Histogram
+}
+
+func NewMetrics(reg prometheus.Registerer, normMean, normDomain float64) *metrics {
+	m := &metrics{
+		// Create a summary to track fictional inter service RPC latencies for three
+		// distinct services with different latency distributions. These services are
+		// differentiated via a "service" label.
+		rpcDurations: prometheus.NewSummaryVec(
+			prometheus.SummaryOpts{
+				Name:       "rpc_durations_seconds",
+				Help:       "RPC latency distributions.",
+				Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
+			},
+			[]string{"service"},
+		),
+		// The same as above, but now as a histogram, and only for the normal
+		// distribution. The buckets are targeted to the parameters of the
+		// normal distribution, with 20 buckets centered on the mean, each
+		// half-sigma wide.
+		rpcDurationsHistogram: prometheus.NewHistogram(prometheus.HistogramOpts{
+			Name:    "rpc_durations_histogram_seconds",
+			Help:    "RPC latency distributions.",
+			Buckets: prometheus.LinearBuckets(normMean-5*normDomain, .5*normDomain, 20),
+		}),
+	}
+	reg.MustRegister(m.rpcDurations)
+	reg.MustRegister(m.rpcDurationsHistogram)
+	return m
+}
+
 func main() {
 	var (
 		addr              = flag.String("listen-address", ":8080", "The address to listen on for HTTP requests.")
@@ -41,34 +74,13 @@ func main() {
 
 	flag.Parse()
 
-	var (
+	// Create a non-global registry.
-		// Create a summary to track fictional interservice RPC latencies for three
+	reg := prometheus.NewRegistry()
-		// distinct services with different latency distributions. These services are
-		// differentiated via a "service" label.
-		rpcDurations = prometheus.NewSummaryVec(
-			prometheus.SummaryOpts{
-				Name:       "rpc_durations_seconds",
-				Help:       "RPC latency distributions.",
-				Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
-			},
-			[]string{"service"},
-		)
-		// The same as above, but now as a histogram, and only for the normal
-		// distribution. The buckets are targeted to the parameters of the
-		// normal distribution, with 20 buckets centered on the mean, each
-		// half-sigma wide.
-		rpcDurationsHistogram = prometheus.NewHistogram(prometheus.HistogramOpts{
-			Name:    "rpc_durations_histogram_seconds",
-			Help:    "RPC latency distributions.",
-			Buckets: prometheus.LinearBuckets(*normMean-5**normDomain, .5**normDomain, 20),
-		})
-	)
 
-	// Register the summary and the histogram with Prometheus's default registry.
+	// Create new metrics and register them using the custom registry.
-	prometheus.MustRegister(rpcDurations)
+	m := NewMetrics(reg, *normMean, *normDomain)
-	prometheus.MustRegister(rpcDurationsHistogram)
 	// Add Go module build info.
-	prometheus.MustRegister(collectors.NewBuildInfoCollector())
+	reg.MustRegister(collectors.NewBuildInfoCollector())
 
 	start := time.Now()
 
@@ -80,7 +92,7 @@ func main() {
 	go func() {
 		for {
 			v := rand.Float64() * *uniformDomain
-			rpcDurations.WithLabelValues("uniform").Observe(v)
+			m.rpcDurations.WithLabelValues("uniform").Observe(v)
 			time.Sleep(time.Duration(100*oscillationFactor()) * time.Millisecond)
 		}
 	}()
@@ -88,14 +100,14 @@ func main() {
 	go func() {
 		for {
 			v := (rand.NormFloat64() * *normDomain) + *normMean
-			rpcDurations.WithLabelValues("normal").Observe(v)
+			m.rpcDurations.WithLabelValues("normal").Observe(v)
 			// Demonstrate exemplar support with a dummy ID. This
 			// would be something like a trace ID in a real
 			// application.  Note the necessary type assertion. We
 			// already know that rpcDurationsHistogram implements
 			// the ExemplarObserver interface and thus don't need to
 			// check the outcome of the type assertion.
-			rpcDurationsHistogram.(prometheus.ExemplarObserver).ObserveWithExemplar(
+			m.rpcDurationsHistogram.(prometheus.ExemplarObserver).ObserveWithExemplar(
 				v, prometheus.Labels{"dummyID": fmt.Sprint(rand.Intn(100000))},
 			)
 			time.Sleep(time.Duration(75*oscillationFactor()) * time.Millisecond)
@@ -105,17 +117,19 @@ func main() {
 	go func() {
 		for {
 			v := rand.ExpFloat64() / 1e6
-			rpcDurations.WithLabelValues("exponential").Observe(v)
+			m.rpcDurations.WithLabelValues("exponential").Observe(v)
 			time.Sleep(time.Duration(50*oscillationFactor()) * time.Millisecond)
 		}
 	}()
 
 	// Expose the registered metrics via HTTP.
 	http.Handle("/metrics", promhttp.HandlerFor(
-		prometheus.DefaultGatherer,
+		reg,
 		promhttp.HandlerOpts{
 			// Opt into OpenMetrics to support exemplars.
 			EnableOpenMetrics: true,
+			// Pass custom registry
+			Registry: reg,
 		},
 	))
 	log.Fatal(http.ListenAndServe(*addr, nil))

examples/simple/main.go

@@ -19,6 +19,7 @@ import (
 	"log"
 	"net/http"
 
+	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
 
@@ -26,6 +27,11 @@ var addr = flag.String("listen-address", ":8080", "The address to listen on for
 
 func main() {
 	flag.Parse()
-	http.Handle("/metrics", promhttp.Handler())
+
+	// Create non-global registry.
+	reg := prometheus.NewRegistry()
+
+	// Expose /metrics HTTP endpoint using the created custom registry.
+	http.Handle("/metrics", promhttp.HandlerFor(reg, promhttp.HandlerOpts{Registry: reg}))
 	log.Fatal(http.ListenAndServe(*addr, nil))
 }

prometheus/doc.go

@@ -35,39 +35,51 @@
 //    	"github.com/prometheus/client_golang/prometheus/promhttp"
 //    )
 //
-//    var (
+//    type metrics struct {
-//    	cpuTemp = prometheus.NewGauge(prometheus.GaugeOpts{
+//    	cpuTemp  prometheus.Gauge
+//      hdFailures *prometheus.CounterVec
+//    }
+//
+//    func NewMetrics(reg prometheus.Registerer) *metrics {
+//      m := &metrics{
+//        cpuTemp: prometheus.NewGauge(prometheus.GaugeOpts{
 //          Name: "cpu_temperature_celsius",
 //          Help: "Current temperature of the CPU.",
-//    	})
+//        }),
-//    	hdFailures = prometheus.NewCounterVec(
+//        hdFailures: prometheus.NewCounterVec(
 //          prometheus.CounterOpts{
 //            Name: "hd_errors_total",
 //            Help: "Number of hard-disk errors.",
 //          },
 //          []string{"device"},
-//    	)
+//        ),
-//    )
+//      }
-//
+//      reg.MustRegister(m.cpuTemp)
-//    func init() {
+//      reg.MustRegister(m.hdFailures)
-//    	// Metrics have to be registered to be exposed:
+//      return m
-//    	prometheus.MustRegister(cpuTemp)
-//    	prometheus.MustRegister(hdFailures)
 //    }
 //
 //    func main() {
-//    	cpuTemp.Set(65.3)
+//      // Create a non-global registry.
-//    	hdFailures.With(prometheus.Labels{"device":"/dev/sda"}).Inc()
+//      reg := prometheus.NewRegistry()
 //
-//    	// The Handler function provides a default handler to expose metrics
+//      // Create new metrics and register them using the custom registry.
-//    	// via an HTTP server. "/metrics" is the usual endpoint for that.
+//      m := NewMetrics(reg)
-//    	http.Handle("/metrics", promhttp.Handler())
+//      // Set values for the new created metrics.
+//    	m.cpuTemp.Set(65.3)
+//    	m.hdFailures.With(prometheus.Labels{"device":"/dev/sda"}).Inc()
+//
+//    	// Expose metrics and custom registry via an HTTP server
+//    	// using the HandleFor function. "/metrics" is the usual endpoint for that.
+//    	http.Handle("/metrics", promhttp.HandlerFor(reg, promhttp.HandlerOpts{Registry: reg}))
 //    	log.Fatal(http.ListenAndServe(":8080", nil))
 //    }
 //
 //
 // This is a complete program that exports two metrics, a Gauge and a Counter,
 // the latter with a label attached to turn it into a (one-dimensional) vector.
+// It register the metrics using a custom registry and exposes them via an HTTP server
+// on the /metrics endpoint.
 //
 // Metrics
 //