Пример #1
0
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
}
Пример #2
0
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)},
	}
}
Пример #3
0
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(),
	}
}
Пример #4
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
}
Пример #5
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
}
Пример #6
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
}
Пример #7
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}
}
Пример #8
0
func NewHttp() *Http {
	return &Http{
		Txns:     util.NewBroadcast(),
		reqGauge: metrics.NewGauge(),
		reqMeter: metrics.NewMeter(),
		reqTimer: metrics.NewTimer(),
	}
}
Пример #9
0
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
}
Пример #10
0
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(),
	}
}
Пример #11
0
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},
	})
}
Пример #12
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
}
Пример #13
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))
			}
		}
	}
}
Пример #14
0
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
}
Пример #15
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
}
Пример #16
0
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)}
}
Пример #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 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
}
Пример #19
0
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,
	})
}