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} }
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} }
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} }
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} }
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 }
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 }
// 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)) } } } }
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 }
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} }
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 }
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 }
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 }
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} }
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) }
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) }
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()) } }
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 }
// 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} }