func NewSubjectPrefixMatchFilter(next Filter, subjectPrefixes []string) *SubjectPrefixMatchFilter {
	total := metrics.NewCounter()
	matched := metrics.NewCounter()
	metrics.Register("SubjectPrefixMatchFilter-Total", total)
	metrics.Register("SubjectPrefixMatchFilter-Matched", matched)
	return &SubjectPrefixMatchFilter{next, subjectPrefixes, total, matched}
}
Пример #2
0
func NewRelayOnlyFilter(next Filter, localDomain string) *RelayOnlyFilter {
	total := metrics.NewCounter()
	numOfRelay := metrics.NewCounter()
	metrics.Register("RelayOnlyFilter-Total", total)
	metrics.Register("RelayOnlyFilter-Relay", numOfRelay)
	return &RelayOnlyFilter{next, localDomain, total, numOfRelay}
}
Пример #3
0
func NewFileHandlerAdapter(updater Updater, factory mailfile.MailFileFactory) *FileHandlerAdapter {
	total := metrics.NewCounter()
	meter := metrics.NewMeter()
	metrics.Register("FileHandlerAdapter-Total", total)
	metrics.Register("FileHandlerAdapter-Size", meter)
	return &FileHandlerAdapter{updater, factory, total, meter}
}
func NewContentInspectionUpdater(anlz analyzer.Analyzer, class string) *ContentInspectionUpdater {
	total := metrics.NewCounter()
	malformed := metrics.NewCounter()
	metrics.Register("ContentInspectionUpdater-Total", total)
	metrics.Register("ContentInspectionUpdater-Malformed", malformed)

	return &ContentInspectionUpdater{anlz, class, total, malformed}
}
Пример #5
0
func NewDeliverFilter(next Filter, paths map[Result]string) *DeliverFilter {
	total := metrics.NewCounter()
	metrics.Register("DeliverFilter-Total", total)

	counters := make(map[Result]metrics.Counter)
	for result, path := range paths {
		counter := metrics.NewCounter()
		counters[result] = counter
		metrics.Register("DeliverFilter-"+path, counter)
	}
	return &DeliverFilter{next, paths, total, counters}
}
Пример #6
0
func NewGoInternalMetrics(prefix string) *GoInternalMetrics {
	goint := &GoInternalMetrics{
		Alloc:        gmetrics.NewGauge(),
		TotalAlloc:   gmetrics.NewGauge(),
		NumGoroutine: gmetrics.NewGauge(),
	}

	gmetrics.Register(prefix+".goint.alloc", goint.Alloc)
	gmetrics.Register(prefix+".goint.total_alloc", goint.TotalAlloc)
	gmetrics.Register(prefix+".goint.go_routines", goint.NumGoroutine)

	return goint
}
Пример #7
0
func NewProcessCpuMetrics(prefix string) *ProcessCpuMetrics {
	cpu := &ProcessCpuMetrics{
		User:  gmetrics.NewMeter(),
		Sys:   gmetrics.NewMeter(),
		Total: gmetrics.NewMeter(),
	}

	gmetrics.Register(prefix+".cpu.user", cpu.User)
	gmetrics.Register(prefix+".cpu.sys", cpu.Sys)
	gmetrics.Register(prefix+".cpu.total", cpu.Total)

	return cpu
}
Пример #8
0
// initializeFieldTagPath traverses the given struct trying to initialize
// metric values.  The "metric" struct tag is used to determine the name of the
// metrics for each struct field. If there is no "metric" struct tag, the
// lowercased struct field name is used for the metric name. The name is
// prefixed with tags from previous struct fields if any, separated by a dot.
// For example:
//
//     	Messages struct {
//          Smtp struct {
//              Latency metrics.Timer `metric:"latency"`
//          } `metric:"smtp"`
//          Http struct {
//              Latency metrics.Timer `metric:"latency"`
//          } `metric:"http"`
//      } `metric:"messages"`
//
// yields timers with names "messages.smtp.latency" and "messages.http.latency"
// respectively.
//
// If there is no metric tag for a field it is skipped and assumed it is used
// for other purposes such as configuration.
func (m *MetricTags) initializeFieldTagPath(fieldType reflect.Value, prefix string) {
	for i := 0; i < fieldType.NumField(); i++ {
		val := fieldType.Field(i)
		field := fieldType.Type().Field(i)

		tag := field.Tag.Get("metric")
		if tag == "" {
			// If tag isn't found, derive tag from the lower case name of
			// the field.
			tag = strings.ToLower(field.Name)
		}
		if prefix != "" {
			tag = prefix + m.separator + tag
		}

		if field.Type.Kind() == reflect.Struct {
			// Recursively traverse an embedded struct
			m.initializeFieldTagPath(val, tag)
		} else if field.Type.Kind() == reflect.Map && field.Type.Key().Kind() == reflect.String {
			// If this is a map[string]Something, then use the string key as bucket name and recursively generate the metrics below
			for _, k := range val.MapKeys() {
				m.initializeFieldTagPath(val.MapIndex(k).Elem(), tag+m.separator+k.String())
			}
		} else {
			// Found a field, initialize
			switch field.Type.String() {
			case "metrics.Counter":
				c := metrics.NewCounter()
				metrics.Register(tag, c)
				val.Set(reflect.ValueOf(c))
			case "metrics.Timer":
				t := metrics.NewTimer()
				metrics.Register(tag, t)
				val.Set(reflect.ValueOf(t))
			case "metrics.Meter":
				m := metrics.NewMeter()
				metrics.Register(tag, m)
				val.Set(reflect.ValueOf(m))
			case "metrics.Gauge":
				g := metrics.NewGauge()
				metrics.Register(tag, g)
				val.Set(reflect.ValueOf(g))
			case "metrics.Histogram":
				s := metrics.NewUniformSample(1028)
				h := metrics.NewHistogram(s)
				metrics.Register(tag, h)
				val.Set(reflect.ValueOf(h))
			}
		}
	}
}
Пример #9
0
func NewProcessMemoryMetrics(prefix string) *ProcessMemoryMetrics {

	mem := &ProcessMemoryMetrics{
		Resident:   gmetrics.NewGauge(),
		Shared:     gmetrics.NewGauge(),
		PageFaults: gmetrics.NewMeter(),
	}

	gmetrics.Register(prefix+".mem.resident", mem.Resident)
	gmetrics.Register(prefix+".mem.shared", mem.Shared)
	gmetrics.Register(prefix+".mem.pagefaults", mem.PageFaults)

	return mem
}
Пример #10
0
func NewLoadMetrics(prefix string) *LoadMetrics {

	load := &LoadMetrics{
		One:     gmetrics.NewGaugeFloat64(),
		Five:    gmetrics.NewGaugeFloat64(),
		Fifteen: gmetrics.NewGaugeFloat64(),
	}

	gmetrics.Register(prefix+".load.1min", load.One)
	gmetrics.Register(prefix+".load.5min", load.Five)
	gmetrics.Register(prefix+".load.15min", load.Fifteen)

	return load
}
func NewContentInspectionFilter(next Filter, allPass bool, anlz analyzer.Analyzer) *ContentInspectionFilter {
	total := metrics.NewCounter()
	metrics.Register("ContentInspectionFilter-Total", total)
	counters := make(map[string]metrics.Counter)
	for _, class := range []string{analyzer.Good, analyzer.Bad, analyzer.Neutral} {
		counter := metrics.NewCounter()
		counters[class] = counter
		metrics.Register("ContentInspectionFilter-"+class, counter)
	}
	malformed := metrics.NewCounter()
	metrics.Register("ContentInspectionFilter-Malformed", malformed)

	return &ContentInspectionFilter{next, allPass, anlz, total, malformed, counters}
}
Пример #12
0
func NewUpstreamMetrics(upstreamId string) UpstreamMetrics {
	hm := NewHttpMetrics(fmt.Sprintf("vulcan.upstream.%s", upstreamId))
	um := UpstreamMetrics{
		Requests:  gmetrics.NewMeter(),
		Failovers: gmetrics.NewMeter(),
		Latency:   gmetrics.NewTimer(),
		Http:      &hm,
	}

	gmetrics.Register(fmt.Sprintf("vulcan.upstream.%s.requests", upstreamId), um.Requests)
	gmetrics.Register(fmt.Sprintf("vulcan.upstream.%s.latency", upstreamId), um.Failovers)
	gmetrics.Register(fmt.Sprintf("vulcan.upstream.%s.failovers", upstreamId), um.Failovers)

	return um
}
Пример #13
0
func NewProxyMetrics() ProxyMetrics {
	pm := ProxyMetrics{
		Requests:        gmetrics.NewMeter(),
		CmdReply:        gmetrics.NewMeter(),
		CmdForward:      gmetrics.NewMeter(),
		RequestBodySize: gmetrics.NewHistogram(gmetrics.NewExpDecaySample(1028, 0.015)),
	}

	gmetrics.Register("vulcan.proxy.requests", pm.Requests)
	gmetrics.Register("vulcan.proxy.cmd_reply", pm.CmdReply)
	gmetrics.Register("vulcan.proxy.cmd_forward", pm.CmdForward)
	gmetrics.Register("vulcan.proxy.request_body_size", pm.RequestBodySize)

	return pm
}
Пример #14
0
func (g *goMetricRegistry) Register(name string, metric accounting.Metric) errors.Error {
	err := metrics.Register(name, metric)
	if err != nil {
		return errors.NewAdminMakeMetricError(err, name)
	}
	return nil
}
Пример #15
0
func NewCachingProxy(target Filter, size int) *CachingProxy {
	_, ok := target.(CacheKey)
	if !ok {
		log.Fatalf("%s should implement CacheKey interface\n", target)
		return nil
	}

	total := metrics.NewCounter()
	hit := metrics.NewCounter()
	cached := metrics.NewGauge()

	targetName := fmt.Sprintf("%s", target)

	metrics.Register("CachingProxy("+targetName+")-Total", total)
	metrics.Register("CachingProxy("+targetName+")-Hit", hit)
	metrics.Register("CachingProxy("+targetName+")-Cached", cached)
	return &CachingProxy{target, &sync.RWMutex{}, list.New(), size, total, hit, cached}
}
Пример #16
0
func (cw *ClusterWatcher) Watch(stop chan interface{}) error {

	if cw.DataDogAPIKey != "" {
		cw.errorsGauge = metrics.NewGauge()
		cw.startedGauge = metrics.NewGauge()
		cw.passivatedGauge = metrics.NewGauge()
		cw.warningsGauge = metrics.NewGauge()

		metrics.Register("arken.environments.stats.errors", cw.errorsGauge)
		metrics.Register("arken.environments.stats.started", cw.startedGauge)
		metrics.Register("arken.environments.stats.passivated", cw.passivatedGauge)
		metrics.Register("arken.environments.stats.warning", cw.warningsGauge)

		host, _ := os.Hostname()
		cw.dog = datadog.New(host, cw.DataDogAPIKey)
		go cw.dog.DefaultReporter().Start(30 * time.Second)

	}

	go cw.updateMetrics()

	return cw.watchServiceKeys(stop)

}
Пример #17
0
func (hm *HttpMetrics) markSingleCode(statusCode int) {
	// TOOD(pquerna): profile to see if this is horrible
	hm.rcmutex.Lock()
	defer hm.rcmutex.Unlock()
	var meter gmetrics.Meter

	meter, ok := hm.ResponseCodes[statusCode]

	if !ok {
		hm.ResponseCodes[statusCode] = gmetrics.NewMeter()
		meter = hm.ResponseCodes[statusCode]
		gmetrics.Register(fmt.Sprintf("%s.http.status.%d", hm.prefix, statusCode), meter)
	}

	meter.Mark(1)
}
Пример #18
0
func TestHandler(t *testing.T) {
	gometrics.UseNilMetrics = true
	gometrics.Register("some.metric.key", gometrics.NewTimer())

	rw := httptest.NewRecorder()
	r, _ := http.NewRequest("GET", "http://example.com", nil)
	Default.ServeHTTP(rw, r)

	if rw.Code != http.StatusOK {
		t.Errorf("Metrics endpoint responded with wrong status code = %d", rw.Code)
	}

	if rw.Body.String() != testJSONMetrics {
		t.Errorf("Wrong metrics response. Want '%s', got '%s'", testJSONMetrics, rw.Body.String())
	}
}
Пример #19
0
func NewHttpMetrics(prefix string) HttpMetrics {
	hm := HttpMetrics{prefix: prefix,
		ResponseRanges: map[string]gmetrics.Meter{
			"1XX": gmetrics.NewMeter(),
			"2XX": gmetrics.NewMeter(),
			"3XX": gmetrics.NewMeter(),
			"4XX": gmetrics.NewMeter(),
			"5XX": gmetrics.NewMeter(),
			"UNK": gmetrics.NewMeter(),
		},
		ResponseCodes: make(map[int]gmetrics.Meter),
	}

	for k, v := range hm.ResponseRanges {
		gmetrics.Register(fmt.Sprintf("%s.http.%s", prefix, k), v)
	}

	return hm
}
Пример #20
0
// conf.Environment, conf.Region
func NewProxyMetrics(env string, region string) ProxyMetrics {

	prefix := buildPrefix(env, region)

	pm := ProxyMetrics{
		Msgs:        gmetrics.NewMeter(),
		MsgReply:    gmetrics.NewMeter(),
		MsgForward:  gmetrics.NewMeter(),
		MsgBodySize: gmetrics.NewHistogram(gmetrics.NewExpDecaySample(1028, 0.015)),
		Connects:    gmetrics.NewMeter(),
		Connections: gmetrics.NewGauge(),
	}

	gmetrics.Register(prefix+".proxy.msgs", pm.Msgs)
	gmetrics.Register(prefix+".proxy.msg_reply", pm.Msgs)
	gmetrics.Register(prefix+".proxy.msg_forward", pm.Msgs)
	gmetrics.Register(prefix+".proxy.msg_body_size", pm.MsgBodySize)
	gmetrics.Register(prefix+".proxy.connects", pm.Connects)
	gmetrics.Register(prefix+".proxy.connections", pm.Connections)

	return pm
}
func NewDefaultDestinationFilter() *DefaultDestinationFilter {
	total := metrics.NewCounter()
	metrics.Register("DefaultDestinationFilter-Total", total)
	return &DefaultDestinationFilter{total}
}