Beispiel #1
0
// NewKeyServerMeasured creates and returns a new KeyServerMeasured
// instance with the given delegate and registry.
func NewKeyServerMeasured(delegate KeyServer, r metrics.Registry) KeyServerMeasured {
	getTimer := metrics.GetOrRegisterTimer("KeyServer.GetTLFCryptKeyServerHalf", r)
	putTimer := metrics.GetOrRegisterTimer("KeyServer.PutTLFCryptKeyServerHalves", r)
	deleteTimer := metrics.GetOrRegisterTimer("KeyServer.DeleteTLFCryptKeyServerHalf", r)
	return KeyServerMeasured{
		delegate:    delegate,
		getTimer:    getTimer,
		putTimer:    putTimer,
		deleteTimer: deleteTimer,
	}
}
Beispiel #2
0
// NewKeyCacheMeasured creates and returns a new KeyCacheMeasured
// instance with the given delegate and registry.
func NewKeyCacheMeasured(delegate KeyCache, r metrics.Registry) KeyCacheMeasured {
	getTimer := metrics.GetOrRegisterTimer("KeyCache.GetTLFCryptKey", r)
	putTimer := metrics.GetOrRegisterTimer("KeyCache.PutTLFCryptKey", r)
	// TODO: Implement RatioGauge (
	// http://metrics.dropwizard.io/3.1.0/manual/core/#ratio-gauges
	// ) so we can actually display a hit ratio.
	hitCountMeter := metrics.GetOrRegisterMeter("KeyCache.HitCount", r)
	return KeyCacheMeasured{
		delegate:      delegate,
		getTimer:      getTimer,
		putTimer:      putTimer,
		hitCountMeter: hitCountMeter,
	}
}
Beispiel #3
0
// NewBlockServerMeasured creates and returns a new
// BlockServerMeasured instance with the given delegate and registry.
func NewBlockServerMeasured(delegate BlockServer, r metrics.Registry) BlockServerMeasured {
	getTimer := metrics.GetOrRegisterTimer("BlockServer.Get", r)
	putTimer := metrics.GetOrRegisterTimer("BlockServer.Put", r)
	addBlockReferenceTimer := metrics.GetOrRegisterTimer("BlockServer.AddBlockReference", r)
	removeBlockReferenceTimer := metrics.GetOrRegisterTimer("BlockServer.RemoveBlockReference", r)
	archiveBlockReferencesTimer := metrics.GetOrRegisterTimer("BlockServer.ArchiveBlockReferences", r)
	return BlockServerMeasured{
		delegate:                    delegate,
		getTimer:                    getTimer,
		putTimer:                    putTimer,
		addBlockReferenceTimer:      addBlockReferenceTimer,
		removeBlockReferenceTimer:   removeBlockReferenceTimer,
		archiveBlockReferencesTimer: archiveBlockReferencesTimer,
	}
}
Beispiel #4
0
func (s *PeerStats) Receive(msg proto.Message) MessageStatus {
	status := PassThrough
	name := shortName(msg)
	latencyName, latencyId := latencyName(msg, true)
	s.mu.Lock()
	defer s.mu.Unlock()
	s.Received[name]++
	if latencyName != "" {
		status = Expected
		if s.InFlight != latencyName+":"+latencyId {
			s.Unexpected++
			status = Unexpected
		}
		s.InFlight = ""
		// metrics.GetOrRegisterCounter(latencyName, nil).Inc(1)
		if l, ok := s.Latencies[latencyName]; ok {
			metrics.GetOrRegisterTimer(latencyName, nil).UpdateSince(l.Last)
			diff := time.Now().Sub(l.Last)
			l.Total += diff
			if diff < l.Min {
				l.Min = diff
			}
			if diff > l.Max {
				l.Max = diff
			}
			l.Count++

		} else {
			panic(name)
		}
	}
	return status
}
Beispiel #5
0
func newHTTPServer(config IssConfig, auth authenticater.Authenticater, fixerFunc FixerFunc, deliverer deliverer) *httpServer {
	return &httpServer{
		auth:           auth,
		Config:         config,
		FixerFunc:      fixerFunc,
		deliverer:      deliverer,
		shutdownCh:     make(shutdownCh),
		posts:          metrics.GetOrRegisterTimer("log-iss.http.logs", config.MetricsRegistry),
		healthChecks:   metrics.GetOrRegisterTimer("log-iss.http.healthchecks", config.MetricsRegistry),
		pErrors:        metrics.GetOrRegisterCounter("log-iss.http.logs.errors", config.MetricsRegistry),
		pSuccesses:     metrics.GetOrRegisterCounter("log-iss.http.logs.successes", config.MetricsRegistry),
		pAuthErrors:    metrics.GetOrRegisterCounter("log-iss.auth.errors", config.MetricsRegistry),
		pAuthSuccesses: metrics.GetOrRegisterCounter("log-iss.auth.successes", config.MetricsRegistry),
		isShuttingDown: false,
	}
}
Beispiel #6
0
func New(tr http.RoundTripper, cfg config.Proxy) *Proxy {
	return &Proxy{
		tr:       tr,
		cfg:      cfg,
		requests: gometrics.GetOrRegisterTimer("requests", gometrics.DefaultRegistry),
	}
}
Beispiel #7
0
func (r *Route) addTarget(service string, targetURL *url.URL, fixedWeight float64, tags []string) {
	if fixedWeight < 0 {
		fixedWeight = 0
	}

	name := metrics.TargetName(service, r.Host, r.Path, targetURL)
	timer := gometrics.GetOrRegisterTimer(name, metrics.ServiceRegistry)

	t := &Target{Service: service, Tags: tags, URL: targetURL, FixedWeight: fixedWeight, Timer: timer, timerName: name}
	r.Targets = append(r.Targets, t)
	r.weighTargets()
}
Beispiel #8
0
func (m *Metrics) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	now := time.Now()

	h := &monitor{writer: w}
	m.handler.ServeHTTP(h, r)

	dur := time.Now().Sub(now)

	if h.code == 0 {
		h.code = 200
	}
	key := "zmon.response." + strconv.Itoa(h.code) + "." + r.Method + "." + m.UrlToKey(r, h.code)
	metrics.GetOrRegisterTimer(key, reg).Update(dur)
}
Beispiel #9
0
func newForwarder(config IssConfig, inbox chan payload, id int) *forwarder {
	me := fmt.Sprintf("log-iss.forwarder.%d", id)
	return &forwarder{
		ID:           id,
		Config:       config,
		Inbox:        inbox,
		duration:     metrics.GetOrRegisterTimer(me+".duration", config.MetricsRegistry),
		cDisconnects: metrics.GetOrRegisterCounter(me+".disconnects", config.MetricsRegistry),
		cSuccesses:   metrics.GetOrRegisterCounter(me+".connect.successes", config.MetricsRegistry),
		cErrors:      metrics.GetOrRegisterCounter(me+".connect.errors", config.MetricsRegistry),
		wErrors:      metrics.GetOrRegisterCounter(me+".write.errors", config.MetricsRegistry),
		wSuccesses:   metrics.GetOrRegisterCounter(me+".write.successes", config.MetricsRegistry),
		wBytes:       metrics.GetOrRegisterCounter(me+".write.bytes", config.MetricsRegistry),
	}
}
func TestFilters(t *testing.T) {
	mock := &MockPutMetricsClient{}
	cfg := &config.Config{
		Client: mock,
		Filter: &config.AllFilter{},
	}
	registry := metrics.NewRegistry()
	timer := metrics.GetOrRegisterTimer(fmt.Sprintf("timer"), registry)
	timer.Update(10 * time.Second)
	emitMetrics(registry, cfg)

	if mock.metricsPut > 0 {
		t.Fatal("Metrics Put")
	}
}
// NewKeybaseDaemonMeasured creates and returns a new KeybaseDaemonMeasured
// instance with the given delegate and registry.
func NewKeybaseDaemonMeasured(delegate KeybaseDaemon, r metrics.Registry) KeybaseDaemonMeasured {
	resolveTimer := metrics.GetOrRegisterTimer("KeybaseDaemon.Resolve", r)
	identifyTimer := metrics.GetOrRegisterTimer("KeybaseDaemon.Identify", r)
	loadUserPlusKeysTimer := metrics.GetOrRegisterTimer("KeybaseDaemon.LoadUserPlusKeys", r)
	currentSessionTimer := metrics.GetOrRegisterTimer("KeybaseDaemon.CurrentSession", r)
	favoriteAddTimer := metrics.GetOrRegisterTimer("KeybaseDaemon.FavoriteAdd", r)
	favoriteDeleteTimer := metrics.GetOrRegisterTimer("KeybaseDaemon.FavoriteDelete", r)
	favoriteListTimer := metrics.GetOrRegisterTimer("KeybaseDaemon.FavoriteList", r)
	notifyTimer := metrics.GetOrRegisterTimer("KeybaseDaemon.Notify", r)
	return KeybaseDaemonMeasured{
		delegate:              delegate,
		resolveTimer:          resolveTimer,
		identifyTimer:         identifyTimer,
		loadUserPlusKeysTimer: loadUserPlusKeysTimer,
		currentSessionTimer:   currentSessionTimer,
		favoriteAddTimer:      favoriteAddTimer,
		favoriteDeleteTimer:   favoriteDeleteTimer,
		favoriteListTimer:     favoriteListTimer,
		notifyTimer:           notifyTimer,
	}
}
Beispiel #12
0
func (g *goMetricRegistry) Timer(name string) accounting.Timer {
	return metrics.GetOrRegisterTimer(name, metrics.DefaultRegistry)
}
Beispiel #13
0
func (p *gmRegistry) GetTimer(name string) Timer {
	return gm.GetOrRegisterTimer(name, p.r)
}