func (s *MemcacheStats) publishSlabsStats() {
s.slabs.mu.Lock()
defer s.slabs.mu.Unlock()
for key, isSingle := range slabsSingleMetrics {
key := key
s.slabs.stats[key] = make(map[string]int64)
if isSingle {
f := func() int64 {
s.slabs.mu.Lock()
defer s.slabs.mu.Unlock()
s.updateSlabsStats()
return s.slabs.stats[key][""]
}
stats.Publish(s.cachePool.name+"MemcacheSlabs"+formatKey(key), stats.IntFunc(f))
continue
}
f := func() map[string]int64 {
s.slabs.mu.Lock()
defer s.slabs.mu.Unlock()
s.updateSlabsStats()
return copyMap(s.slabs.stats[key])
}
stats.Publish(s.cachePool.name+"MemcacheSlabs"+formatKey(key), stats.CountersFunc(f))
}
}
func NewSchemaInfo(queryCacheSize int, reloadTime time.Duration, idleTimeout time.Duration, sensitiveMode bool) *SchemaInfo {
si := &SchemaInfo{
queryCacheSize: queryCacheSize,
queries: cache.NewLRUCache(int64(queryCacheSize)),
rules: NewQueryRules(),
connPool: NewConnectionPool("", 2, idleTimeout),
reloadTime: reloadTime,
ticks: timer.NewTimer(reloadTime),
sensitiveMode: sensitiveMode,
}
stats.Publish("QueryCacheLength", stats.IntFunc(si.queries.Length))
stats.Publish("QueryCacheSize", stats.IntFunc(si.queries.Size))
stats.Publish("QueryCacheCapacity", stats.IntFunc(si.queries.Capacity))
stats.Publish("QueryCacheOldest", stats.StringFunc(func() string {
return fmt.Sprintf("%v", si.queries.Oldest())
}))
stats.Publish("SchemaReloadTime", stats.DurationFunc(func() time.Duration {
return si.reloadTime
}))
stats.Publish("TableStats", stats.NewMatrixFunc("Table", "Stats", si.getTableStats))
stats.Publish("TableInvalidations", stats.CountersFunc(si.getTableInvalidations))
stats.Publish("QueryCounts", stats.NewMatrixFunc("Table", "Plan", si.getQueryCount))
stats.Publish("QueryTimesNs", stats.NewMatrixFunc("Table", "Plan", si.getQueryTime))
stats.Publish("QueryRowCounts", stats.NewMatrixFunc("Table", "Plan", si.getQueryRowCount))
stats.Publish("QueryErrorCounts", stats.NewMatrixFunc("Table", "Plan", si.getQueryErrorCount))
// query_plans cannot be shown in sensitive mode
if !si.sensitiveMode {
http.Handle("/debug/query_plans", si)
}
http.Handle("/debug/query_stats", si)
http.Handle("/debug/table_stats", si)
http.Handle("/debug/schema", si)
return si
}
// RegisterBinlogPlayerMap registers the varz for the players
func RegisterBinlogPlayerMap(blm *BinlogPlayerMap) {
stats.Publish("BinlogPlayerMapSize", stats.IntFunc(blm.size))
stats.Publish("BinlogPlayerSecondsBehindMaster", stats.IntFunc(func() int64 {
sbm := int64(0)
blm.mu.Lock()
for _, bpc := range blm.players {
psbm := bpc.binlogPlayerStats.SecondsBehindMaster.Get()
if psbm > sbm {
sbm = psbm
}
}
blm.mu.Unlock()
return sbm
}))
stats.Publish("BinlogPlayerSecondsBehindMasterMap", stats.CountersFunc(func() map[string]int64 {
blm.mu.Lock()
result := make(map[string]int64, len(blm.players))
for i, bpc := range blm.players {
sbm := bpc.binlogPlayerStats.SecondsBehindMaster.Get()
result[fmt.Sprintf("%v", i)] = sbm
}
blm.mu.Unlock()
return result
}))
stats.Publish("BinlogPlayerGTIDMap", stats.StringMapFunc(func() map[string]string {
blm.mu.Lock()
result := make(map[string]string, len(blm.players))
for i, bpc := range blm.players {
lgtid := bpc.binlogPlayerStats.GetLastGTID()
result[fmt.Sprintf("%v", i)] = myproto.EncodeGTID(lgtid)
}
blm.mu.Unlock()
return result
}))
stats.Publish("BinlogPlayerSourceShardNameMap", stats.StringMapFunc(func() map[string]string {
blm.mu.Lock()
result := make(map[string]string, len(blm.players))
for i, bpc := range blm.players {
name := bpc.sourceShard.Keyspace + "/" + bpc.sourceShard.Shard
result[fmt.Sprintf("%v", i)] = name
}
blm.mu.Unlock()
return result
}))
stats.Publish("BinlogPlayerSourceTabletAliasMap", stats.StringMapFunc(func() map[string]string {
blm.mu.Lock()
result := make(map[string]string, len(blm.players))
for i, bpc := range blm.players {
bpc.playerMutex.Lock()
result[fmt.Sprintf("%v", i)] = bpc.sourceTablet.String()
bpc.playerMutex.Unlock()
}
blm.mu.Unlock()
return result
}))
}
func TestCountersFunc(t *testing.T) {
f := func() map[string]int64 {
return map[string]int64{"a": 1234}
}
v := stats.CountersFunc(f)
testMetric(t, v, nil,
`Desc{fqName: "test_name", help: "test_help", constLabels: {}, variableLabels: [tag]}`,
`label:<name:"tag" value:"a" > gauge:<value:1234 > `,
)
}
func main() {
flag.Parse()
servenv.Init()
// For the initial phase vtgate is exposing
// topoReader api. This will be subsumed by
// vtgate once vtgate's client functions become active.
ts := topo.GetServer()
defer topo.CloseServers()
rts := vtgate.NewResilientSrvTopoServer(ts)
stats.Publish("EndpointCount", stats.CountersFunc(rts.HealthyEndpointCount))
stats.Publish("DegradedEndpointCount", stats.CountersFunc(rts.DegradedEndpointCount))
topoReader = NewTopoReader(rts)
topo.RegisterTopoReader(topoReader)
vtgate.Init(rts, *cell, *retryDelay, *retryCount, *timeout)
servenv.Run()
}
func (memstats *MemcacheStats) publishItemsStats() {
memstats.mu.Lock()
defer memstats.mu.Unlock()
for _, key := range itemsMetrics {
key := key // create local var to keep current key
memstats.items[key] = make(map[string]int64)
stats.Publish(memstats.statsPrefix+"MemcacheItems"+formatKey(key), stats.CountersFunc(func() map[string]int64 {
memstats.mu.Lock()
defer memstats.mu.Unlock()
return copyMap(memstats.items[key])
}))
}
}
func (s *MemcacheStats) publishItemsStats() {
s.mu.Lock()
defer s.mu.Unlock()
s.items = make(map[string]map[string]int64)
for _, key := range itemsMetrics {
key := key // create local var to keep current key
s.items[key] = make(map[string]int64)
stats.Publish(s.cachePool.name+"MemcacheItems"+formatKey(key), stats.CountersFunc(func() map[string]int64 {
s.mu.Lock()
defer s.mu.Unlock()
return copyMap(s.items[key])
}))
}
}
// RegisterBinlogPlayerMap registers the varz for the players.
func RegisterBinlogPlayerMap(blm *BinlogPlayerMap) {
stats.Publish("BinlogPlayerMapSize", stats.IntFunc(stats.IntFunc(func() int64 {
blm.mu.Lock()
defer blm.mu.Unlock()
return int64(len(blm.players))
})))
stats.Publish("BinlogPlayerSecondsBehindMaster", stats.IntFunc(func() int64 {
blm.mu.Lock()
defer blm.mu.Unlock()
return blm.maxSecondsBehindMasterUNGUARDED()
}))
stats.Publish("BinlogPlayerSecondsBehindMasterMap", stats.CountersFunc(func() map[string]int64 {
blm.mu.Lock()
result := make(map[string]int64, len(blm.players))
for i, bpc := range blm.players {
sbm := bpc.binlogPlayerStats.SecondsBehindMaster.Get()
result[fmt.Sprintf("%v", i)] = sbm
}
blm.mu.Unlock()
return result
}))
stats.Publish("BinlogPlayerSourceShardNameMap", stats.StringMapFunc(func() map[string]string {
blm.mu.Lock()
result := make(map[string]string, len(blm.players))
for i, bpc := range blm.players {
name := bpc.sourceShard.Keyspace + "/" + bpc.sourceShard.Shard
result[fmt.Sprintf("%v", i)] = name
}
blm.mu.Unlock()
return result
}))
stats.Publish("BinlogPlayerSourceTabletAliasMap", stats.StringMapFunc(func() map[string]string {
blm.mu.Lock()
result := make(map[string]string, len(blm.players))
for i, bpc := range blm.players {
bpc.playerMutex.Lock()
result[fmt.Sprintf("%v", i)] = bpc.sourceTablet.String()
bpc.playerMutex.Unlock()
}
blm.mu.Unlock()
return result
}))
}
func (memstats *MemcacheStats) publishSlabsStats() {
memstats.mu.Lock()
defer memstats.mu.Unlock()
for key, isSingle := range slabsSingleMetrics {
key := key
memstats.slabs[key] = make(map[string]int64)
if isSingle {
stats.Publish(memstats.statsPrefix+"MemcacheSlabs"+formatKey(key), stats.IntFunc(func() int64 {
memstats.mu.Lock()
defer memstats.mu.Unlock()
return memstats.slabs[key][""]
}))
} else {
stats.Publish(memstats.statsPrefix+"MemcacheSlabs"+formatKey(key), stats.CountersFunc(func() map[string]int64 {
memstats.mu.Lock()
defer memstats.mu.Unlock()
return copyMap(memstats.slabs[key])
}))
}
}
}