From 9fccb9698965f218e4c89633096bd5154fc1447e Mon Sep 17 00:00:00 2001 From: Bernerd Schaefer Date: Fri, 19 Apr 2013 14:44:15 +0200 Subject: [PATCH] Remove timer.go and timer_test.go --- prometheus/registry.go | 31 +++++++++--------- prometheus/telemetry.go | 4 +-- prometheus/timer.go | 62 ------------------------------------ prometheus/timer_test.go | 69 ---------------------------------------- 4 files changed, 17 insertions(+), 149 deletions(-) delete mode 100644 prometheus/timer.go delete mode 100644 prometheus/timer_test.go diff --git a/prometheus/registry.go b/prometheus/registry.go index 28ab774..d968d3f 100644 --- a/prometheus/registry.go +++ b/prometheus/registry.go @@ -18,6 +18,7 @@ import ( "sort" "strings" "sync" + "time" ) const ( @@ -269,29 +270,27 @@ func (registry registry) YieldExporter() http.HandlerFunc { func (registry registry) Handler() http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { - var instrumentable InstrumentableCall = func() { - requestCount.Increment(nil) - url := r.URL + defer requestLatencyAccumulator(time.Now()) - if strings.HasSuffix(url.Path, jsonSuffix) { - header := w.Header() - header.Set(ProtocolVersionHeader, APIVersion) - header.Set(contentTypeHeader, jsonContentType) + requestCount.Increment(nil) + url := r.URL - writer := decorateWriter(r, w) + if strings.HasSuffix(url.Path, jsonSuffix) { + header := w.Header() + header.Set(ProtocolVersionHeader, APIVersion) + header.Set(contentTypeHeader, jsonContentType) - if closer, ok := writer.(io.Closer); ok { - defer closer.Close() - } + writer := decorateWriter(r, w) - registry.dumpToWriter(writer) - - } else { - w.WriteHeader(http.StatusNotFound) + if closer, ok := writer.(io.Closer); ok { + defer closer.Close() } + registry.dumpToWriter(writer) + + } else { + w.WriteHeader(http.StatusNotFound) } - InstrumentCall(instrumentable, requestLatencyAccumulator) } } diff --git a/prometheus/telemetry.go b/prometheus/telemetry.go index 3cfa3fb..dc048bd 100644 --- a/prometheus/telemetry.go +++ b/prometheus/telemetry.go @@ -40,8 +40,8 @@ func init() { // This callback accumulates the microsecond duration of the reporting // framework's overhead such that it can be reported. -var requestLatencyAccumulator CompletionCallback = func(duration time.Duration) { - microseconds := float64(duration / time.Microsecond) +var requestLatencyAccumulator = func(began time.Time) { + microseconds := float64(time.Since(began) / time.Microsecond) requestLatency.Add(nil, microseconds) } diff --git a/prometheus/timer.go b/prometheus/timer.go deleted file mode 100644 index aa1ff92..0000000 --- a/prometheus/timer.go +++ /dev/null @@ -1,62 +0,0 @@ -// Copyright (c) 2013, Prometheus Team -// All rights reserved. -// -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package prometheus - -import ( - "time" -) - -// This callback is called upon the completion of the timer—i.e., when it stops. -type CompletionCallback func(duration time.Duration) - -// This is meant to capture a function that a StopWatch can call for purposes -// of instrumentation. -type InstrumentableCall func() - -// StopWatch is the structure that captures instrumentation for durations. - -// N.B.(mtp): A major limitation hereof is that the StopWatch protocol cannot -// retain instrumentation if a panic percolates within the context that is -// being measured. -type StopWatch interface { - Stop() time.Duration -} - -type stopWatch struct { - endTime time.Time - onCompletion CompletionCallback - startTime time.Time -} - -// Return a new StopWatch that is ready for instrumentation. -func Start(onCompletion CompletionCallback) StopWatch { - return &stopWatch{ - onCompletion: onCompletion, - startTime: time.Now(), - } -} - -// Stop the StopWatch returning the elapsed duration of its lifetime while -// firing an optional CompletionCallback in the background. -func (s *stopWatch) Stop() time.Duration { - s.endTime = time.Now() - duration := s.endTime.Sub(s.startTime) - - if s.onCompletion != nil { - go s.onCompletion(duration) - } - - return duration -} - -// Provide a quick way of instrumenting a InstrumentableCall and emitting its -// duration. -func InstrumentCall(instrumentable InstrumentableCall, onCompletion CompletionCallback) time.Duration { - s := Start(onCompletion) - instrumentable() - return s.Stop() -} diff --git a/prometheus/timer_test.go b/prometheus/timer_test.go deleted file mode 100644 index e9dab08..0000000 --- a/prometheus/timer_test.go +++ /dev/null @@ -1,69 +0,0 @@ -// Copyright (c) 2013, Prometheus Team -// All rights reserved. -// -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package prometheus - -import ( - . "github.com/matttproud/gocheck" - "time" -) - -func (s *S) TestTimerStart(c *C) { - stopWatch, ok := Start(nil).(*stopWatch) - if !ok { - c.Check(ok, Equals, true) - } - - c.Assert(stopWatch, Not(IsNil)) - c.Assert(stopWatch.startTime, Not(IsNil)) -} - -func (s *S) TestTimerStop(c *C) { - done := make(chan bool) - - var callbackInvoked bool = false - var complete CompletionCallback = func(duration time.Duration) { - callbackInvoked = true - done <- true - } - - stopWatch := Start(complete) - - c.Check(callbackInvoked, Equals, false) - - d := stopWatch.Stop() - - <-done - - c.Assert(d, Not(IsNil)) - c.Check(callbackInvoked, Equals, true) -} - -func (s *S) TestInstrumentCall(c *C) { - var callbackInvoked bool = false - var instrumentableInvoked bool = false - done := make(chan bool, 2) - - var complete CompletionCallback = func(duration time.Duration) { - callbackInvoked = true - done <- true - } - - var instrumentable InstrumentableCall = func() { - instrumentableInvoked = true - done <- true - } - - d := InstrumentCall(instrumentable, complete) - - c.Assert(d, Not(IsNil)) - - <-done - <-done - - c.Check(instrumentableInvoked, Equals, true) - c.Check(callbackInvoked, Equals, true) -}