Use snapshots in all the reporters.

graphite.go

@@ -26,46 +26,48 @@ func graphite(r Registry, prefix string, addr *net.TCPAddr) error {
 	defer conn.Close()
 	w := bufio.NewWriter(conn)
 	r.Each(func(name string, i interface{}) {
-		switch m := i.(type) {
+		switch metric := i.(type) {
 		case Counter:
-			fmt.Fprintf(w, "%s.%s.count %d %d\n", prefix, name, m.Count(), now)
+			fmt.Fprintf(w, "%s.%s.count %d %d\n", prefix, name, metric.Count(), now)
 		case Gauge:
-			fmt.Fprintf(w, "%s.%s.value %d %d\n", prefix, name, m.Value(), now)
+			fmt.Fprintf(w, "%s.%s.value %d %d\n", prefix, name, metric.Value(), now)
 		case Histogram:
-			s := m.Sample()
-			ps := s.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
-			fmt.Fprintf(w, "%s.%s.count %d %d\n", prefix, name, s.Count(), now)
-			fmt.Fprintf(w, "%s.%s.min %d %d\n", prefix, name, s.Min(), now)
-			fmt.Fprintf(w, "%s.%s.max %d %d\n", prefix, name, s.Max(), now)
-			fmt.Fprintf(w, "%s.%s.mean %.2f %d\n", prefix, name, s.Mean(), now)
-			fmt.Fprintf(w, "%s.%s.std-dev %.2f %d\n", prefix, name, s.StdDev(), now)
+			h := metric.Snapshot()
+			ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
+			fmt.Fprintf(w, "%s.%s.count %d %d\n", prefix, name, h.Count(), now)
+			fmt.Fprintf(w, "%s.%s.min %d %d\n", prefix, name, h.Min(), now)
+			fmt.Fprintf(w, "%s.%s.max %d %d\n", prefix, name, h.Max(), now)
+			fmt.Fprintf(w, "%s.%s.mean %.2f %d\n", prefix, name, h.Mean(), now)
+			fmt.Fprintf(w, "%s.%s.std-dev %.2f %d\n", prefix, name, h.StdDev(), now)
 			fmt.Fprintf(w, "%s.%s.50-percentile %.2f %d\n", prefix, name, ps[0], now)
 			fmt.Fprintf(w, "%s.%s.75-percentile %.2f %d\n", prefix, name, ps[1], now)
 			fmt.Fprintf(w, "%s.%s.95-percentile %.2f %d\n", prefix, name, ps[2], now)
 			fmt.Fprintf(w, "%s.%s.99-percentile %.2f %d\n", prefix, name, ps[3], now)
 			fmt.Fprintf(w, "%s.%s.999-percentile %.2f %d\n", prefix, name, ps[4], now)
 		case Meter:
+			m := metric.Snapshot()
 			fmt.Fprintf(w, "%s.%s.count %d %d\n", prefix, name, m.Count(), now)
 			fmt.Fprintf(w, "%s.%s.one-minute %.2f %d\n", prefix, name, m.Rate1(), now)
 			fmt.Fprintf(w, "%s.%s.five-minute %.2f %d\n", prefix, name, m.Rate5(), now)
 			fmt.Fprintf(w, "%s.%s.fifteen-minute %.2f %d\n", prefix, name, m.Rate15(), now)
 			fmt.Fprintf(w, "%s.%s.mean %.2f %d\n", prefix, name, m.RateMean(), now)
 		case Timer:
-			ps := m.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
-			fmt.Fprintf(w, "%s.%s.count %d %d\n", prefix, name, m.Count(), now)
-			fmt.Fprintf(w, "%s.%s.min %d %d\n", prefix, name, m.Min(), now)
-			fmt.Fprintf(w, "%s.%s.max %d %d\n", prefix, name, m.Max(), now)
-			fmt.Fprintf(w, "%s.%s.mean %.2f %d\n", prefix, name, m.Mean(), now)
-			fmt.Fprintf(w, "%s.%s.std-dev %.2f %d\n", prefix, name, m.StdDev(), now)
+			t := metric.Snapshot()
+			ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
+			fmt.Fprintf(w, "%s.%s.count %d %d\n", prefix, name, t.Count(), now)
+			fmt.Fprintf(w, "%s.%s.min %d %d\n", prefix, name, t.Min(), now)
+			fmt.Fprintf(w, "%s.%s.max %d %d\n", prefix, name, t.Max(), now)
+			fmt.Fprintf(w, "%s.%s.mean %.2f %d\n", prefix, name, t.Mean(), now)
+			fmt.Fprintf(w, "%s.%s.std-dev %.2f %d\n", prefix, name, t.StdDev(), now)
 			fmt.Fprintf(w, "%s.%s.50-percentile %.2f %d\n", prefix, name, ps[0], now)
 			fmt.Fprintf(w, "%s.%s.75-percentile %.2f %d\n", prefix, name, ps[1], now)
 			fmt.Fprintf(w, "%s.%s.95-percentile %.2f %d\n", prefix, name, ps[2], now)
 			fmt.Fprintf(w, "%s.%s.99-percentile %.2f %d\n", prefix, name, ps[3], now)
 			fmt.Fprintf(w, "%s.%s.999-percentile %.2f %d\n", prefix, name, ps[4], now)
-			fmt.Fprintf(w, "%s.%s.one-minute %.2f %d\n", prefix, name, m.Rate1(), now)
-			fmt.Fprintf(w, "%s.%s.five-minute %.2f %d\n", prefix, name, m.Rate5(), now)
-			fmt.Fprintf(w, "%s.%s.fifteen-minute %.2f %d\n", prefix, name, m.Rate15(), now)
-			fmt.Fprintf(w, "%s.%s.mean-rate %.2f %d\n", prefix, name, m.RateMean(), now)
+			fmt.Fprintf(w, "%s.%s.one-minute %.2f %d\n", prefix, name, t.Rate1(), now)
+			fmt.Fprintf(w, "%s.%s.five-minute %.2f %d\n", prefix, name, t.Rate5(), now)
+			fmt.Fprintf(w, "%s.%s.fifteen-minute %.2f %d\n", prefix, name, t.Rate15(), now)
+			fmt.Fprintf(w, "%s.%s.mean-rate %.2f %d\n", prefix, name, t.RateMean(), now)
 		}
 		w.Flush()
 	})

json.go

@@ -8,49 +8,51 @@ func (r StandardRegistry) MarshalJSON() ([]byte, error) {
 	data := make(map[string]map[string]interface{})
 	r.Each(func(name string, i interface{}) {
 		values := make(map[string]interface{})
-		switch m := i.(type) {
+		switch metric := i.(type) {
 		case Counter:
-			values["count"] = m.Count()
+			values["count"] = metric.Count()
 		case Gauge:
-			values["value"] = m.Value()
+			values["value"] = metric.Value()
 		case Healthcheck:
-			m.Check()
-			values["error"] = m.Error()
+			metric.Check()
+			values["error"] = metric.Error().Error()
 		case Histogram:
-			s := m.Sample()
-			ps := s.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
-			values["count"] = s.Count()
-			values["min"] = s.Min()
-			values["max"] = s.Max()
-			values["mean"] = s.Mean()
-			values["stddev"] = s.StdDev()
+			h := metric.Snapshot()
+			ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
+			values["count"] = h.Count()
+			values["min"] = h.Min()
+			values["max"] = h.Max()
+			values["mean"] = h.Mean()
+			values["stddev"] = h.StdDev()
 			values["median"] = ps[0]
-			values["75%%"] = ps[1]
-			values["95%%"] = ps[2]
-			values["99%%"] = ps[3]
-			values["99.9%%"] = ps[4]
+			values["75%"] = ps[1]
+			values["95%"] = ps[2]
+			values["99%"] = ps[3]
+			values["99.9%"] = ps[4]
 		case Meter:
+			m := metric.Snapshot()
 			values["count"] = m.Count()
 			values["1m.rate"] = m.Rate1()
 			values["5m.rate"] = m.Rate5()
 			values["15m.rate"] = m.Rate15()
 			values["mean.rate"] = m.RateMean()
 		case Timer:
-			ps := m.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
-			values["count"] = m.Count()
-			values["min"] = m.Min()
-			values["max"] = m.Max()
-			values["mean"] = m.Mean()
-			values["stddev"] = m.StdDev()
+			t := metric.Snapshot()
+			ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
+			values["count"] = t.Count()
+			values["min"] = t.Min()
+			values["max"] = t.Max()
+			values["mean"] = t.Mean()
+			values["stddev"] = t.StdDev()
 			values["median"] = ps[0]
-			values["75%%"] = ps[1]
-			values["95%%"] = ps[2]
-			values["99%%"] = ps[3]
-			values["99.9%%"] = ps[4]
-			values["1m.rate"] = m.Rate1()
-			values["5m.rate"] = m.Rate5()
-			values["15m.rate"] = m.Rate15()
-			values["mean.rate"] = m.RateMean()
+			values["75%"] = ps[1]
+			values["95%"] = ps[2]
+			values["99%"] = ps[3]
+			values["99.9%"] = ps[4]
+			values["1m.rate"] = t.Rate1()
+			values["5m.rate"] = t.Rate5()
+			values["15m.rate"] = t.Rate15()
+			values["mean.rate"] = t.RateMean()
 		}
 		data[name] = values
 	})

log.go

@@ -10,32 +10,33 @@ import (
 func Log(r Registry, d time.Duration, l *log.Logger) {
 	for {
 		r.Each(func(name string, i interface{}) {
-			switch m := i.(type) {
+			switch metric := i.(type) {
 			case Counter:
 				l.Printf("counter %s\n", name)
-				l.Printf("  count:       %9d\n", m.Count())
+				l.Printf("  count:       %9d\n", metric.Count())
 			case Gauge:
 				l.Printf("gauge %s\n", name)
-				l.Printf("  value:       %9d\n", m.Value())
+				l.Printf("  value:       %9d\n", metric.Value())
 			case Healthcheck:
-				m.Check()
+				metric.Check()
 				l.Printf("healthcheck %s\n", name)
-				l.Printf("  error:       %v\n", m.Error())
+				l.Printf("  error:       %v\n", metric.Error())
 			case Histogram:
-				s := m.Sample()
-				ps := s.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
+				h := metric.Snapshot()
+				ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
 				l.Printf("histogram %s\n", name)
-				l.Printf("  count:       %9d\n", s.Count())
-				l.Printf("  min:         %9d\n", s.Min())
-				l.Printf("  max:         %9d\n", s.Max())
-				l.Printf("  mean:        %12.2f\n", s.Mean())
-				l.Printf("  stddev:      %12.2f\n", s.StdDev())
+				l.Printf("  count:       %9d\n", h.Count())
+				l.Printf("  min:         %9d\n", h.Min())
+				l.Printf("  max:         %9d\n", h.Max())
+				l.Printf("  mean:        %12.2f\n", h.Mean())
+				l.Printf("  stddev:      %12.2f\n", h.StdDev())
 				l.Printf("  median:      %12.2f\n", ps[0])
 				l.Printf("  75%%:         %12.2f\n", ps[1])
 				l.Printf("  95%%:         %12.2f\n", ps[2])
 				l.Printf("  99%%:         %12.2f\n", ps[3])
 				l.Printf("  99.9%%:       %12.2f\n", ps[4])
 			case Meter:
+				m := metric.Snapshot()
 				l.Printf("meter %s\n", name)
 				l.Printf("  count:       %9d\n", m.Count())
 				l.Printf("  1-min rate:  %12.2f\n", m.Rate1())
@@ -43,22 +44,23 @@ func Log(r Registry, d time.Duration, l *log.Logger) {
 				l.Printf("  15-min rate: %12.2f\n", m.Rate15())
 				l.Printf("  mean rate:   %12.2f\n", m.RateMean())
 			case Timer:
-				ps := m.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
+				t := metric.Snapshot()
+				ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
 				l.Printf("timer %s\n", name)
-				l.Printf("  count:       %9d\n", m.Count())
-				l.Printf("  min:         %9d\n", m.Min())
-				l.Printf("  max:         %9d\n", m.Max())
-				l.Printf("  mean:        %12.2f\n", m.Mean())
-				l.Printf("  stddev:      %12.2f\n", m.StdDev())
+				l.Printf("  count:       %9d\n", t.Count())
+				l.Printf("  min:         %9d\n", t.Min())
+				l.Printf("  max:         %9d\n", t.Max())
+				l.Printf("  mean:        %12.2f\n", t.Mean())
+				l.Printf("  stddev:      %12.2f\n", t.StdDev())
 				l.Printf("  median:      %12.2f\n", ps[0])
 				l.Printf("  75%%:         %12.2f\n", ps[1])
 				l.Printf("  95%%:         %12.2f\n", ps[2])
 				l.Printf("  99%%:         %12.2f\n", ps[3])
 				l.Printf("  99.9%%:       %12.2f\n", ps[4])
-				l.Printf("  1-min rate:  %12.2f\n", m.Rate1())
-				l.Printf("  5-min rate:  %12.2f\n", m.Rate5())
-				l.Printf("  15-min rate: %12.2f\n", m.Rate15())
-				l.Printf("  mean rate:   %12.2f\n", m.RateMean())
+				l.Printf("  1-min rate:  %12.2f\n", t.Rate1())
+				l.Printf("  5-min rate:  %12.2f\n", t.Rate5())
+				l.Printf("  15-min rate: %12.2f\n", t.Rate15())
+				l.Printf("  mean rate:   %12.2f\n", t.RateMean())
 			}
 		})
 		time.Sleep(d)

stathat/stathat.go

@@ -19,46 +19,48 @@ func Stathat(r metrics.Registry, d time.Duration, userkey string) {
 
 func sh(r metrics.Registry, userkey string) error {
 	r.Each(func(name string, i interface{}) {
-		switch m := i.(type) {
+		switch metric := i.(type) {
 		case metrics.Counter:
-			stathat.PostEZCount(name, userkey, int(m.Count()))
+			stathat.PostEZCount(name, userkey, int(metric.Count()))
 		case metrics.Gauge:
-			stathat.PostEZValue(name, userkey, float64(m.Value()))
+			stathat.PostEZValue(name, userkey, float64(metric.Value()))
 		case metrics.Histogram:
-			s := m.Sample()
-			ps := s.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
-			stathat.PostEZCount(name+".count", userkey, int(s.Count()))
-			stathat.PostEZValue(name+".min", userkey, float64(s.Min()))
-			stathat.PostEZValue(name+".max", userkey, float64(s.Max()))
-			stathat.PostEZValue(name+".mean", userkey, float64(s.Mean()))
-			stathat.PostEZValue(name+".std-dev", userkey, float64(s.StdDev()))
+			h := metric.Snapshot()
+			ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
+			stathat.PostEZCount(name+".count", userkey, int(h.Count()))
+			stathat.PostEZValue(name+".min", userkey, float64(h.Min()))
+			stathat.PostEZValue(name+".max", userkey, float64(h.Max()))
+			stathat.PostEZValue(name+".mean", userkey, float64(h.Mean()))
+			stathat.PostEZValue(name+".std-dev", userkey, float64(h.StdDev()))
 			stathat.PostEZValue(name+".50-percentile", userkey, float64(ps[0]))
 			stathat.PostEZValue(name+".75-percentile", userkey, float64(ps[1]))
 			stathat.PostEZValue(name+".95-percentile", userkey, float64(ps[2]))
 			stathat.PostEZValue(name+".99-percentile", userkey, float64(ps[3]))
 			stathat.PostEZValue(name+".999-percentile", userkey, float64(ps[4]))
 		case metrics.Meter:
+			m := metric.Snapshot()
 			stathat.PostEZCount(name+".count", userkey, int(m.Count()))
 			stathat.PostEZValue(name+".one-minute", userkey, float64(m.Rate1()))
 			stathat.PostEZValue(name+".five-minute", userkey, float64(m.Rate5()))
 			stathat.PostEZValue(name+".fifteen-minute", userkey, float64(m.Rate15()))
 			stathat.PostEZValue(name+".mean", userkey, float64(m.RateMean()))
 		case metrics.Timer:
-			ps := m.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
-			stathat.PostEZCount(name+".count", userkey, int(m.Count()))
-			stathat.PostEZValue(name+".min", userkey, float64(m.Min()))
-			stathat.PostEZValue(name+".max", userkey, float64(m.Max()))
-			stathat.PostEZValue(name+".mean", userkey, float64(m.Mean()))
-			stathat.PostEZValue(name+".std-dev", userkey, float64(m.StdDev()))
+			t := metric.Snapshot()
+			ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
+			stathat.PostEZCount(name+".count", userkey, int(t.Count()))
+			stathat.PostEZValue(name+".min", userkey, float64(t.Min()))
+			stathat.PostEZValue(name+".max", userkey, float64(t.Max()))
+			stathat.PostEZValue(name+".mean", userkey, float64(t.Mean()))
+			stathat.PostEZValue(name+".std-dev", userkey, float64(t.StdDev()))
 			stathat.PostEZValue(name+".50-percentile", userkey, float64(ps[0]))
 			stathat.PostEZValue(name+".75-percentile", userkey, float64(ps[1]))
 			stathat.PostEZValue(name+".95-percentile", userkey, float64(ps[2]))
 			stathat.PostEZValue(name+".99-percentile", userkey, float64(ps[3]))
 			stathat.PostEZValue(name+".999-percentile", userkey, float64(ps[4]))
-			stathat.PostEZValue(name+".one-minute", userkey, float64(m.Rate1()))
-			stathat.PostEZValue(name+".five-minute", userkey, float64(m.Rate5()))
-			stathat.PostEZValue(name+".fifteen-minute", userkey, float64(m.Rate15()))
-			stathat.PostEZValue(name+".mean-rate", userkey, float64(m.RateMean()))
+			stathat.PostEZValue(name+".one-minute", userkey, float64(t.Rate1()))
+			stathat.PostEZValue(name+".five-minute", userkey, float64(t.Rate5()))
+			stathat.PostEZValue(name+".fifteen-minute", userkey, float64(t.Rate15()))
+			stathat.PostEZValue(name+".mean-rate", userkey, float64(t.RateMean()))
 		}
 	})
 	return nil

syslog.go

@@ -13,25 +13,25 @@ import (
 func Syslog(r Registry, d time.Duration, w *syslog.Writer) {
 	for {
 		r.Each(func(name string, i interface{}) {
-			switch m := i.(type) {
+			switch metric := i.(type) {
 			case Counter:
-				w.Info(fmt.Sprintf("counter %s: count: %d", name, m.Count()))
+				w.Info(fmt.Sprintf("counter %s: count: %d", name, metric.Count()))
 			case Gauge:
-				w.Info(fmt.Sprintf("gauge %s: value: %d", name, m.Value()))
+				w.Info(fmt.Sprintf("gauge %s: value: %d", name, metric.Value()))
 			case Healthcheck:
-				m.Check()
-				w.Info(fmt.Sprintf("healthcheck %s: error: %v", name, m.Error()))
+				metric.Check()
+				w.Info(fmt.Sprintf("healthcheck %s: error: %v", name, metric.Error()))
 			case Histogram:
-				s := m.Sample()
-				ps := s.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
+				h := metric.Snapshot()
+				ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
 				w.Info(fmt.Sprintf(
 					"histogram %s: count: %d min: %d max: %d mean: %.2f stddev: %.2f median: %.2f 75%%: %.2f 95%%: %.2f 99%%: %.2f 99.9%%: %.2f",
 					name,
-					s.Count(),
-					s.Min(),
-					s.Max(),
-					s.Mean(),
-					s.StdDev(),
+					h.Count(),
+					h.Min(),
+					h.Max(),
+					h.Mean(),
+					h.StdDev(),
 					ps[0],
 					ps[1],
 					ps[2],
@@ -39,6 +39,7 @@ func Syslog(r Registry, d time.Duration, w *syslog.Writer) {
 					ps[4],
 				))
 			case Meter:
+				m := metric.Snapshot()
 				w.Info(fmt.Sprintf(
 					"meter %s: count: %d 1-min: %.2f 5-min: %.2f 15-min: %.2f mean: %.2f",
 					name,
@@ -49,24 +50,25 @@ func Syslog(r Registry, d time.Duration, w *syslog.Writer) {
 					m.RateMean(),
 				))
 			case Timer:
-				ps := m.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
+				t := metric.Snapshot()
+				ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
 				w.Info(fmt.Sprintf(
 					"timer %s: count: %d min: %d max: %d mean: %.2f stddev: %.2f median: %.2f 75%%: %.2f 95%%: %.2f 99%%: %.2f 99.9%%: %.2f 1-min: %.2f 5-min: %.2f 15-min: %.2f mean-rate: %.2f",
 					name,
-					m.Count(),
-					m.Min(),
-					m.Max(),
-					m.Mean(),
-					m.StdDev(),
+					t.Count(),
+					t.Min(),
+					t.Max(),
+					t.Mean(),
+					t.StdDev(),
 					ps[0],
 					ps[1],
 					ps[2],
 					ps[3],
 					ps[4],
-					m.Rate1(),
-					m.Rate5(),
-					m.Rate15(),
-					m.RateMean(),
+					t.Rate1(),
+					t.Rate5(),
+					t.Rate15(),
+					t.RateMean(),
 				))
 			}
 		})

writer.go

@@ -17,32 +17,33 @@ func Write(r Registry, d time.Duration, w io.Writer) {
 
 func WriteOnce(r Registry, w io.Writer) {
 	r.Each(func(name string, i interface{}) {
-		switch m := i.(type) {
+		switch metric := i.(type) {
 		case Counter:
 			fmt.Fprintf(w, "counter %s\n", name)
-			fmt.Fprintf(w, "  count:       %9d\n", m.Count())
+			fmt.Fprintf(w, "  count:       %9d\n", metric.Count())
 		case Gauge:
 			fmt.Fprintf(w, "gauge %s\n", name)
-			fmt.Fprintf(w, "  value:       %9d\n", m.Value())
+			fmt.Fprintf(w, "  value:       %9d\n", metric.Value())
 		case Healthcheck:
-			m.Check()
+			metric.Check()
 			fmt.Fprintf(w, "healthcheck %s\n", name)
-			fmt.Fprintf(w, "  error:       %v\n", m.Error())
+			fmt.Fprintf(w, "  error:       %v\n", metric.Error())
 		case Histogram:
-			s := m.Sample()
-			ps := s.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
+			h := metric.Snapshot()
+			ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
 			fmt.Fprintf(w, "histogram %s\n", name)
-			fmt.Fprintf(w, "  count:       %9d\n", s.Count())
-			fmt.Fprintf(w, "  min:         %9d\n", s.Min())
-			fmt.Fprintf(w, "  max:         %9d\n", s.Max())
-			fmt.Fprintf(w, "  mean:        %12.2f\n", s.Mean())
-			fmt.Fprintf(w, "  stddev:      %12.2f\n", s.StdDev())
+			fmt.Fprintf(w, "  count:       %9d\n", h.Count())
+			fmt.Fprintf(w, "  min:         %9d\n", h.Min())
+			fmt.Fprintf(w, "  max:         %9d\n", h.Max())
+			fmt.Fprintf(w, "  mean:        %12.2f\n", h.Mean())
+			fmt.Fprintf(w, "  stddev:      %12.2f\n", h.StdDev())
 			fmt.Fprintf(w, "  median:      %12.2f\n", ps[0])
 			fmt.Fprintf(w, "  75%%:         %12.2f\n", ps[1])
 			fmt.Fprintf(w, "  95%%:         %12.2f\n", ps[2])
 			fmt.Fprintf(w, "  99%%:         %12.2f\n", ps[3])
 			fmt.Fprintf(w, "  99.9%%:       %12.2f\n", ps[4])
 		case Meter:
+			m := metric.Snapshot()
 			fmt.Fprintf(w, "meter %s\n", name)
 			fmt.Fprintf(w, "  count:       %9d\n", m.Count())
 			fmt.Fprintf(w, "  1-min rate:  %12.2f\n", m.Rate1())
@@ -50,22 +51,23 @@ func WriteOnce(r Registry, w io.Writer) {
 			fmt.Fprintf(w, "  15-min rate: %12.2f\n", m.Rate15())
 			fmt.Fprintf(w, "  mean rate:   %12.2f\n", m.RateMean())
 		case Timer:
-			ps := m.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
+			t := metric.Snapshot()
+			ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
 			fmt.Fprintf(w, "timer %s\n", name)
-			fmt.Fprintf(w, "  count:       %9d\n", m.Count())
-			fmt.Fprintf(w, "  min:         %9d\n", m.Min())
-			fmt.Fprintf(w, "  max:         %9d\n", m.Max())
-			fmt.Fprintf(w, "  mean:        %12.2f\n", m.Mean())
-			fmt.Fprintf(w, "  stddev:      %12.2f\n", m.StdDev())
+			fmt.Fprintf(w, "  count:       %9d\n", t.Count())
+			fmt.Fprintf(w, "  min:         %9d\n", t.Min())
+			fmt.Fprintf(w, "  max:         %9d\n", t.Max())
+			fmt.Fprintf(w, "  mean:        %12.2f\n", t.Mean())
+			fmt.Fprintf(w, "  stddev:      %12.2f\n", t.StdDev())
 			fmt.Fprintf(w, "  median:      %12.2f\n", ps[0])
 			fmt.Fprintf(w, "  75%%:         %12.2f\n", ps[1])
 			fmt.Fprintf(w, "  95%%:         %12.2f\n", ps[2])
 			fmt.Fprintf(w, "  99%%:         %12.2f\n", ps[3])
 			fmt.Fprintf(w, "  99.9%%:       %12.2f\n", ps[4])
-			fmt.Fprintf(w, "  1-min rate:  %12.2f\n", m.Rate1())
-			fmt.Fprintf(w, "  5-min rate:  %12.2f\n", m.Rate5())
-			fmt.Fprintf(w, "  15-min rate: %12.2f\n", m.Rate15())
-			fmt.Fprintf(w, "  mean rate:   %12.2f\n", m.RateMean())
+			fmt.Fprintf(w, "  1-min rate:  %12.2f\n", t.Rate1())
+			fmt.Fprintf(w, "  5-min rate:  %12.2f\n", t.Rate5())
+			fmt.Fprintf(w, "  15-min rate: %12.2f\n", t.Rate15())
+			fmt.Fprintf(w, "  mean rate:   %12.2f\n", t.RateMean())
 		}
 	})
 }