func NewLocalMetrics(reportInterval time.Duration) *LocalMetrics { metrics := LocalMetrics{ Logger: log.NewPrefixLogger("metrics"), reportInterval: reportInterval, windowsCounter: gometrics.NewCounter(), linuxCounter: gometrics.NewCounter(), osxCounter: gometrics.NewCounter(), otherCounter: gometrics.NewCounter(), tunnelMeter: gometrics.NewMeter(), tcpTunnelMeter: gometrics.NewMeter(), httpTunnelMeter: gometrics.NewMeter(), connMeter: gometrics.NewMeter(), lostHeartbeatMeter: gometrics.NewMeter(), connTimer: gometrics.NewTimer(), bytesInCount: gometrics.NewCounter(), bytesOutCount: gometrics.NewCounter(), /* metrics.tunnelGauge = gometrics.NewGauge(), metrics.tcpTunnelGauge = gometrics.NewGauge(), metrics.connGauge = gometrics.NewGauge(), */ } go metrics.Report() return &metrics }
func NewMetricsDB() *MetricsDB { return &MetricsDB{ connections: mt.NewHistogram(mt.NewExpDecaySample(1028, 0.015)), queries: mt.NewMeter(), executes: mt.NewMeter(), rows: mt.NewMeter(), affects: mt.NewMeter(), timers: &MeticsTimers{timers: make(map[string]mt.Timer)}, } }
func NewMetricsHttp() *MetricsHttp { return &MetricsHttp{ clients: mt.NewHistogram(mt.NewExpDecaySample(1028, 0.015)), clientsCounter: mt.NewCounter(), requests: mt.NewTimer(), status2xx: mt.NewMeter(), status3xx: mt.NewMeter(), status4xx: mt.NewMeter(), status5xx: mt.NewMeter(), } }
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 }
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 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 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 NewHttp() *Http { return &Http{ Txns: util.NewBroadcast(), reqGauge: metrics.NewGauge(), reqMeter: metrics.NewMeter(), reqTimer: metrics.NewTimer(), } }
func NewRocksDB(path string) (*RocksDB, error) { opts := gorocksdb.NewDefaultOptions() filter := gorocksdb.NewBloomFilter(14) opts.SetFilterPolicy(filter) opts.SetMaxOpenFiles(10000) db, err := gorocksdb.OpenDbForReadOnly(opts, path, false) if err != nil { return nil, err } return &RocksDB{ db: db, ro: gorocksdb.NewDefaultReadOptions(), hits: metrics.NewMeter(), misses: metrics.NewMeter(), cache: lru.New(1000000), }, nil }
func NewClientMetrics() *ClientMetrics { return &ClientMetrics{ connGauge: metrics.NewGauge(), connMeter: metrics.NewMeter(), connTimer: metrics.NewTimer(), proxySetupTimer: metrics.NewTimer(), bytesIn: metrics.NewHistogram(metrics.NewExpDecaySample(sampleSize, sampleAlpha)), bytesOut: metrics.NewHistogram(metrics.NewExpDecaySample(sampleSize, sampleAlpha)), bytesInCount: metrics.NewCounter(), bytesOutCount: metrics.NewCounter(), } }
func addGCMetrics(p *newrelic.Plugin) { numGC := metrics.NewMeter() pauseDur := metrics.NewMeter() pauseTime := metrics.NewHistogram(metrics.NewExpDecaySample(10000, 0.015)) gcr := &gcReader{ sampleRate: time.Second * 10, numGC: numGC, pauseDur: pauseDur, pauseTime: pauseTime, } gcr.Run() nrmetrics.AddMeterMetric(p, numGC, nrmetrics.MetricConfig{Name: "GC/GC Pauses Per Second", Unit: "pauses", Rate1: true, Rate5: true, Rate15: true}) nrmetrics.AddMeterMetric(p, pauseDur, nrmetrics.MetricConfig{Name: "GC/GC Pause Time Per Second", Unit: "nanoseconds", Rate1: true, Rate5: true, Rate15: true}) nrmetrics.AddHistogramMetric(p, pauseTime, nrmetrics.MetricConfig{ Name: "GC/GC Time Per Pause", Unit: "pauses", Duration: time.Microsecond, Mean: true, Percentiles: []float64{0.5, 0.75, 0.9, 0.99, 0.999}, }) }
// 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 }
// 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 NewHttpMetric() *HttpMetric { x := &HttpMetric{ Requests: metrics.NewCounter(), Rate: metrics.NewMeter(), Responses2xx: metrics.NewCounter(), Responses3xx: metrics.NewCounter(), Responses4xx: metrics.NewCounter(), Responses5xx: metrics.NewCounter(), ResponsesXxx: metrics.NewCounter(), Latency: metrics.NewHistogram(metrics.NewExpDecaySample(1028, 0.015)), } return x }
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 init() { metrics = &metricsDB{ connections: mt.NewHistogram(mt.NewExpDecaySample(1028, 0.015)), queries: mt.NewMeter(), executes: mt.NewMeter(), rows: mt.NewMeter(), affects: mt.NewMeter(), begins: mt.NewMeter(), commits: mt.NewMeter(), rollbacks: mt.NewMeter(), } timers = &timersDB{timers: make(map[string]mt.Timer)} }
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 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 }
func addMemoryMetrics(p *newrelic.Plugin) { allocInUse := metrics.NewGauge() allocTotal := metrics.NewGauge() sys := metrics.NewGauge() pointerLookups := metrics.NewMeter() mallocs := metrics.NewMeter() frees := metrics.NewMeter() allocHeap := metrics.NewGauge() heapSys := metrics.NewGauge() heapIdle := metrics.NewGauge() heapInUse := metrics.NewGauge() heapReleased := metrics.NewGauge() heapObjects := metrics.NewGauge() stackInUse := metrics.NewGauge() stackSys := metrics.NewGauge() mspanInUse := metrics.NewGauge() mspanSys := metrics.NewGauge() mcacheInUse := metrics.NewGauge() mcacheSys := metrics.NewGauge() buckHashSys := metrics.NewGauge() gcSys := metrics.NewGauge() otherSys := metrics.NewGauge() mr := &memReader{ sampleRate: time.Minute, allocInUse: allocInUse, allocTotal: allocTotal, pointerLookups: pointerLookups, mallocs: mallocs, frees: frees, allocHeap: allocHeap, heapSys: heapSys, heapIdle: heapIdle, heapInUse: heapInUse, heapReleased: heapReleased, heapObjects: heapObjects, stackInUse: stackInUse, stackSys: stackSys, mspanInUse: mspanInUse, mspanSys: mspanSys, mcacheInUse: mcacheInUse, mcacheSys: mcacheSys, buckHashSys: buckHashSys, gcSys: gcSys, otherSys: otherSys, } mr.Run() nrmetrics.AddGaugeMetric(p, allocTotal, nrmetrics.MetricConfig{Name: "Memory/Summary/Allocated Over Time", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, sys, nrmetrics.MetricConfig{Name: "Memory/Summary/System/Total", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, heapSys, nrmetrics.MetricConfig{Name: "Memory/System/Heap", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, stackSys, nrmetrics.MetricConfig{Name: "Memory/System/Stack", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, mspanSys, nrmetrics.MetricConfig{Name: "Memory/System/MSpan", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, mcacheSys, nrmetrics.MetricConfig{Name: "Memory/System/MCache", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, buckHashSys, nrmetrics.MetricConfig{Name: "Memory/System/BuckHash", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, gcSys, nrmetrics.MetricConfig{Name: "Memory/System/GC", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, otherSys, nrmetrics.MetricConfig{Name: "Memory/System/Other", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, allocInUse, nrmetrics.MetricConfig{Name: "Memory/Summary/In Use/Total", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, heapInUse, nrmetrics.MetricConfig{Name: "Memory/In Use/Heap", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, stackInUse, nrmetrics.MetricConfig{Name: "Memory/In Use/Stack", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, mspanInUse, nrmetrics.MetricConfig{Name: "Memory/In Use/MSpan", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, mcacheInUse, nrmetrics.MetricConfig{Name: "Memory/In Use/MCache", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, allocHeap, nrmetrics.MetricConfig{Name: "Memory/Heap/Allocated", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, heapIdle, nrmetrics.MetricConfig{Name: "Memory/Heap/Idle", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, heapInUse, nrmetrics.MetricConfig{Name: "Memory/Heap/In Use", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, heapReleased, nrmetrics.MetricConfig{Name: "Memory/Heap/Released", Unit: "bytes", Value: true}) nrmetrics.AddGaugeMetric(p, heapObjects, nrmetrics.MetricConfig{Name: "Memory/Events/Allocated Heap Objects", Unit: "objects", Value: true}) nrmetrics.AddMeterMetric(p, pointerLookups, nrmetrics.MetricConfig{ Name: "Memory/Events/Pointer Lookups", Unit: "lookups", Rate1: true, Rate5: true, Rate15: true, }) nrmetrics.AddMeterMetric(p, mallocs, nrmetrics.MetricConfig{ Name: "Memory/Events/Mallocs", Unit: "mallocs", Rate1: true, Rate5: true, Rate15: true, }) nrmetrics.AddMeterMetric(p, frees, nrmetrics.MetricConfig{ Name: "Memory/Events/Frees", Unit: "frees", Rate1: true, Rate5: true, Rate15: true, }) }