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