--- /dev/null
+package core
+
+import (
+ "strings"
+ "sync/atomic"
+
+ "git.fd.io/govpp.git/adapter"
+ "git.fd.io/govpp.git/api"
+)
+
+const (
+ CounterStatsPrefix = "/err/"
+
+ SystemStatsPrefix = "/sys/"
+ SystemStats_VectorRate = SystemStatsPrefix + "vector_rate"
+ SystemStats_InputRate = SystemStatsPrefix + "input_rate"
+ SystemStats_LastUpdate = SystemStatsPrefix + "last_update"
+ SystemStats_LastStatsClear = SystemStatsPrefix + "last_stats_clear"
+ SystemStats_Heartbeat = SystemStatsPrefix + "heartbeat"
+
+ NodeStatsPrefix = "/sys/node/"
+ NodeStats_Clocks = NodeStatsPrefix + "clocks"
+ NodeStats_Vectors = NodeStatsPrefix + "vectors"
+ NodeStats_Calls = NodeStatsPrefix + "calls"
+ NodeStats_Suspends = NodeStatsPrefix + "suspends"
+
+ InterfaceStatsPrefix = "/if/"
+ InterfaceStats_Drops = InterfaceStatsPrefix + "drops"
+ InterfaceStats_Punt = InterfaceStatsPrefix + "punt"
+ InterfaceStats_IP4 = InterfaceStatsPrefix + "ip4"
+ InterfaceStats_IP6 = InterfaceStatsPrefix + "ip6"
+ InterfaceStats_RxNoBuf = InterfaceStatsPrefix + "rx-no-buf"
+ InterfaceStats_RxMiss = InterfaceStatsPrefix + "rx-miss"
+ InterfaceStats_RxError = InterfaceStatsPrefix + "rx-error"
+ InterfaceStats_TxError = InterfaceStatsPrefix + "tx-error"
+ InterfaceStats_Rx = InterfaceStatsPrefix + "rx"
+ InterfaceStats_RxUnicast = InterfaceStatsPrefix + "rx-unicast"
+ InterfaceStats_RxMulticast = InterfaceStatsPrefix + "rx-multicast"
+ InterfaceStats_RxBroadcast = InterfaceStatsPrefix + "rx-broadcast"
+ InterfaceStats_Tx = InterfaceStatsPrefix + "tx"
+ InterfaceStats_TxUnicastMiss = InterfaceStatsPrefix + "tx-unicast-miss"
+ InterfaceStats_TxMulticast = InterfaceStatsPrefix + "tx-multicast"
+ InterfaceStats_TxBroadcast = InterfaceStatsPrefix + "tx-broadcast"
+
+ NetworkStatsPrefix = "/net/"
+ NetworkStats_RouteTo = NetworkStatsPrefix + "route/to"
+ NetworkStats_RouteVia = NetworkStatsPrefix + "route/via"
+ NetworkStats_MRoute = NetworkStatsPrefix + "mroute"
+ NetworkStats_Adjacency = NetworkStatsPrefix + "adjacency"
+)
+
+type StatsConnection struct {
+ statsClient adapter.StatsAPI
+
+ connected uint32 // non-zero if the adapter is connected to VPP
+}
+
+func newStatsConnection(stats adapter.StatsAPI) *StatsConnection {
+ return &StatsConnection{
+ statsClient: stats,
+ }
+}
+
+// Connect connects to Stats API using specified adapter and returns a connection handle.
+// This call blocks until it is either connected, or an error occurs.
+// Only one connection attempt will be performed.
+func ConnectStats(stats adapter.StatsAPI) (*StatsConnection, error) {
+ c := newStatsConnection(stats)
+
+ if err := c.connectClient(); err != nil {
+ return nil, err
+ }
+
+ return c, nil
+}
+
+func (c *StatsConnection) connectClient() error {
+ log.Debug("Connecting to stats..")
+
+ if err := c.statsClient.Connect(); err != nil {
+ return err
+ }
+
+ log.Debugf("Connected to stats.")
+
+ // store connected state
+ atomic.StoreUint32(&c.connected, 1)
+
+ return nil
+}
+
+// Disconnect disconnects from Stats API and releases all connection-related resources.
+func (c *StatsConnection) Disconnect() {
+ if c == nil {
+ return
+ }
+
+ if c.statsClient != nil {
+ c.disconnectClient()
+ }
+}
+
+func (c *StatsConnection) disconnectClient() {
+ if atomic.CompareAndSwapUint32(&c.connected, 1, 0) {
+ c.statsClient.Disconnect()
+ }
+}
+
+// GetSystemStats retrieves VPP system stats.
+func (c *StatsConnection) GetSystemStats() (*api.SystemStats, error) {
+ stats, err := c.statsClient.DumpStats(SystemStatsPrefix)
+ if err != nil {
+ return nil, err
+ }
+
+ sysStats := &api.SystemStats{}
+
+ for _, stat := range stats {
+ switch stat.Name {
+ case SystemStats_VectorRate:
+ sysStats.VectorRate = scalarStatToFloat64(stat.Data)
+ case SystemStats_InputRate:
+ sysStats.InputRate = scalarStatToFloat64(stat.Data)
+ case SystemStats_LastUpdate:
+ sysStats.LastUpdate = scalarStatToFloat64(stat.Data)
+ case SystemStats_LastStatsClear:
+ sysStats.LastStatsClear = scalarStatToFloat64(stat.Data)
+ case SystemStats_Heartbeat:
+ sysStats.Heartbeat = scalarStatToFloat64(stat.Data)
+ }
+ }
+
+ return sysStats, nil
+}
+
+// GetErrorStats retrieves VPP error stats.
+func (c *StatsConnection) GetErrorStats(names ...string) (*api.ErrorStats, error) {
+ var patterns []string
+ if len(names) > 0 {
+ patterns = make([]string, len(names))
+ for i, name := range names {
+ patterns[i] = CounterStatsPrefix + name
+ }
+ } else {
+ // retrieve all error counters by default
+ patterns = []string{CounterStatsPrefix}
+ }
+ stats, err := c.statsClient.DumpStats(patterns...)
+ if err != nil {
+ return nil, err
+ }
+
+ var errorStats = &api.ErrorStats{}
+
+ for _, stat := range stats {
+ statName := strings.TrimPrefix(stat.Name, CounterStatsPrefix)
+
+ /* TODO: deal with stats that contain '/' in node/counter name
+ parts := strings.Split(statName, "/")
+ var nodeName, counterName string
+ switch len(parts) {
+ case 2:
+ nodeName = parts[0]
+ counterName = parts[1]
+ case 3:
+ nodeName = parts[0] + parts[1]
+ counterName = parts[2]
+ }*/
+
+ errorStats.Errors = append(errorStats.Errors, api.ErrorCounter{
+ CounterName: statName,
+ Value: errorStatToUint64(stat.Data),
+ })
+ }
+
+ return errorStats, nil
+}
+
+// GetNodeStats retrieves VPP per node stats.
+func (c *StatsConnection) GetNodeStats() (*api.NodeStats, error) {
+ stats, err := c.statsClient.DumpStats(NodeStatsPrefix)
+ if err != nil {
+ return nil, err
+ }
+
+ nodeStats := &api.NodeStats{}
+ var setPerNode = func(perNode []uint64, fn func(c *api.NodeCounters, v uint64)) {
+ if nodeStats.Nodes == nil {
+ nodeStats.Nodes = make([]api.NodeCounters, len(perNode))
+ for i := range perNode {
+ nodeStats.Nodes[i].NodeIndex = uint32(i)
+ }
+ }
+ for i, v := range perNode {
+ nodeCounters := nodeStats.Nodes[i]
+ fn(&nodeCounters, v)
+ nodeStats.Nodes[i] = nodeCounters
+ }
+ }
+
+ for _, stat := range stats {
+ switch stat.Name {
+ case NodeStats_Clocks:
+ setPerNode(reduceSimpleCounterStat(stat.Data), func(c *api.NodeCounters, v uint64) {
+ c.Clocks = v
+ })
+ case NodeStats_Vectors:
+ setPerNode(reduceSimpleCounterStat(stat.Data), func(c *api.NodeCounters, v uint64) {
+ c.Vectors = v
+ })
+ case NodeStats_Calls:
+ setPerNode(reduceSimpleCounterStat(stat.Data), func(c *api.NodeCounters, v uint64) {
+ c.Calls = v
+ })
+ case NodeStats_Suspends:
+ setPerNode(reduceSimpleCounterStat(stat.Data), func(c *api.NodeCounters, v uint64) {
+ c.Suspends = v
+ })
+ }
+ }
+
+ return nodeStats, nil
+}
+
+// GetInterfaceStats retrieves VPP per interface stats.
+func (c *StatsConnection) GetInterfaceStats() (*api.InterfaceStats, error) {
+ stats, err := c.statsClient.DumpStats(InterfaceStatsPrefix)
+ if err != nil {
+ return nil, err
+ }
+
+ ifStats := &api.InterfaceStats{}
+ var setPerIf = func(perIf []uint64, fn func(c *api.InterfaceCounters, v uint64)) {
+ if ifStats.Interfaces == nil {
+ ifStats.Interfaces = make([]api.InterfaceCounters, len(perIf))
+ for i := range perIf {
+ ifStats.Interfaces[i].InterfaceIndex = uint32(i)
+ }
+ }
+ for i, v := range perIf {
+ ifCounters := ifStats.Interfaces[i]
+ fn(&ifCounters, v)
+ ifStats.Interfaces[i] = ifCounters
+ }
+ }
+
+ for _, stat := range stats {
+ switch stat.Name {
+ case InterfaceStats_Drops:
+ setPerIf(reduceSimpleCounterStat(stat.Data), func(c *api.InterfaceCounters, v uint64) {
+ c.Drops = v
+ })
+ case InterfaceStats_Punt:
+ setPerIf(reduceSimpleCounterStat(stat.Data), func(c *api.InterfaceCounters, v uint64) {
+ c.Punts = v
+ })
+ case InterfaceStats_IP4:
+ setPerIf(reduceSimpleCounterStat(stat.Data), func(c *api.InterfaceCounters, v uint64) {
+ c.IP4 = v
+ })
+ case InterfaceStats_IP6:
+ setPerIf(reduceSimpleCounterStat(stat.Data), func(c *api.InterfaceCounters, v uint64) {
+ c.IP6 = v
+ })
+ case InterfaceStats_RxNoBuf:
+ setPerIf(reduceSimpleCounterStat(stat.Data), func(c *api.InterfaceCounters, v uint64) {
+ c.RxNoBuf = v
+ })
+ case InterfaceStats_RxMiss:
+ setPerIf(reduceSimpleCounterStat(stat.Data), func(c *api.InterfaceCounters, v uint64) {
+ c.RxMiss = v
+ })
+ case InterfaceStats_RxError:
+ setPerIf(reduceSimpleCounterStat(stat.Data), func(c *api.InterfaceCounters, v uint64) {
+ c.RxErrors = v
+ })
+ case InterfaceStats_TxError:
+ setPerIf(reduceSimpleCounterStat(stat.Data), func(c *api.InterfaceCounters, v uint64) {
+ c.TxErrors = v
+ })
+ case InterfaceStats_Rx:
+ per := reduceCombinedCounterStat(stat.Data)
+ setPerIf(per[0], func(c *api.InterfaceCounters, v uint64) {
+ c.RxPackets = v
+ })
+ setPerIf(per[1], func(c *api.InterfaceCounters, v uint64) {
+ c.RxBytes = v
+ })
+ case InterfaceStats_RxUnicast:
+ per := reduceCombinedCounterStat(stat.Data)
+ setPerIf(per[0], func(c *api.InterfaceCounters, v uint64) {
+ c.RxUnicast[0] = v
+ })
+ setPerIf(per[1], func(c *api.InterfaceCounters, v uint64) {
+ c.RxUnicast[1] = v
+ })
+ case InterfaceStats_RxMulticast:
+ per := reduceCombinedCounterStat(stat.Data)
+ setPerIf(per[0], func(c *api.InterfaceCounters, v uint64) {
+ c.RxMulticast[0] = v
+ })
+ setPerIf(per[1], func(c *api.InterfaceCounters, v uint64) {
+ c.RxMulticast[1] = v
+ })
+ case InterfaceStats_RxBroadcast:
+ per := reduceCombinedCounterStat(stat.Data)
+ setPerIf(per[0], func(c *api.InterfaceCounters, v uint64) {
+ c.RxBroadcast[0] = v
+ })
+ setPerIf(per[1], func(c *api.InterfaceCounters, v uint64) {
+ c.RxBroadcast[1] = v
+ })
+ case InterfaceStats_Tx:
+ per := reduceCombinedCounterStat(stat.Data)
+ setPerIf(per[0], func(c *api.InterfaceCounters, v uint64) {
+ c.TxPackets = v
+ })
+ setPerIf(per[1], func(c *api.InterfaceCounters, v uint64) {
+ c.TxBytes = v
+ })
+ case InterfaceStats_TxUnicastMiss:
+ per := reduceCombinedCounterStat(stat.Data)
+ setPerIf(per[0], func(c *api.InterfaceCounters, v uint64) {
+ c.TxUnicastMiss[0] = v
+ })
+ setPerIf(per[1], func(c *api.InterfaceCounters, v uint64) {
+ c.TxUnicastMiss[1] = v
+ })
+ case InterfaceStats_TxMulticast:
+ per := reduceCombinedCounterStat(stat.Data)
+ setPerIf(per[0], func(c *api.InterfaceCounters, v uint64) {
+ c.TxMulticast[0] = v
+ })
+ setPerIf(per[1], func(c *api.InterfaceCounters, v uint64) {
+ c.TxMulticast[1] = v
+ })
+ case InterfaceStats_TxBroadcast:
+ per := reduceCombinedCounterStat(stat.Data)
+ setPerIf(per[0], func(c *api.InterfaceCounters, v uint64) {
+ c.TxBroadcast[0] = v
+ })
+ setPerIf(per[1], func(c *api.InterfaceCounters, v uint64) {
+ c.TxBroadcast[1] = v
+ })
+ }
+ }
+
+ return ifStats, nil
+}
+
+func scalarStatToFloat64(stat adapter.Stat) float64 {
+ if s, ok := stat.(adapter.ScalarStat); ok {
+ return float64(s)
+ }
+ return 0
+}
+
+func errorStatToUint64(stat adapter.Stat) uint64 {
+ if s, ok := stat.(adapter.ErrorStat); ok {
+ return uint64(s)
+ }
+ return 0
+}
+
+func reduceSimpleCounterStat(stat adapter.Stat) []uint64 {
+ if s, ok := stat.(adapter.SimpleCounterStat); ok {
+ if len(s) == 0 {
+ return []uint64{}
+ }
+ var per = make([]uint64, len(s[0]))
+ for _, w := range s {
+ for i, n := range w {
+ per[i] += uint64(n)
+ }
+ }
+ return per
+ }
+ return nil
+}
+
+func reduceCombinedCounterStat(stat adapter.Stat) [2][]uint64 {
+ if s, ok := stat.(adapter.CombinedCounterStat); ok {
+ if len(s) == 0 {
+ return [2][]uint64{{}, {}}
+ }
+ var perPackets = make([]uint64, len(s[0]))
+ var perBytes = make([]uint64, len(s[0]))
+ for _, w := range s {
+ for i, n := range w {
+ perPackets[i] += uint64(n.Packets)
+ perBytes[i] += uint64(n.Bytes)
+ }
+ }
+ return [2][]uint64{perPackets, perBytes}
+ }
+ return [2][]uint64{}
+}
```sh
statseg {
default
+ per-node-counters on
}
- ```
+ ```
> The [default socket](https://wiki.fd.io/view/VPP/Command-line_Arguments#.22statseg.22_parameters) is located at `/run/vpp/stats.sock`.
-- run the VPP, ideally with some traffic
+- run the VPP (ideally with some traffic)
## Running example
-First build the example: `go build git.fd.io/govpp.git/examples/stats-api`.
+First build the example: `go build git.fd.io/govpp.git/examples/stats-api`.
-Use commands `ls` and `dump` to list and dump statistics. Optionally, patterns can be used to filter the results.
+### Higher-level access to stats
-### List stats matching patterns `/sys/` and `/if/`
+Use commands following commands to retrieve stats that are aggregated and
+processed into logical structures from [api package](../../api).
+
+- `system` to retrieve system statistics
+- `nodes` to retrieve per node statistics
+- `interfaces` to retrieve per interface statistics
+- `errors` to retrieve error statistics (you can use patterns to filter the errors)
+
+#### System stats
+
+Following command will retrieve system stats.
+```
+$ ./stats-api system
+System stats: &{VectorRate:0 InputRate:0 LastUpdate:32560 LastStatsClear:0 Heartbeat:3255}
+```
+
+#### Node stats
+
+Following command will retrieve per node stats.
+```
+$ ./stats-api nodes
+Listing node stats..
+...
+ - {NodeIndex:554 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+ - {NodeIndex:555 Clocks:189609 Vectors:15 Calls:15 Suspends:0}
+ - {NodeIndex:556 Clocks:2281847 Vectors:0 Calls:0 Suspends:21}
+ - {NodeIndex:557 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+ - {NodeIndex:558 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+ - {NodeIndex:559 Clocks:7094 Vectors:0 Calls:1 Suspends:1}
+ - {NodeIndex:560 Clocks:88159323916601 Vectors:0 Calls:14066116 Suspends:0}
+ - {NodeIndex:561 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+ - {NodeIndex:562 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+ - {NodeIndex:563 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+ - {NodeIndex:564 Clocks:447894125 Vectors:0 Calls:0 Suspends:32395}
+ - {NodeIndex:565 Clocks:1099655497824612 Vectors:0 Calls:40 Suspends:117}
+ - {NodeIndex:566 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+ - {NodeIndex:567 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+ - {NodeIndex:568 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+ - {NodeIndex:569 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+ - {NodeIndex:570 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+ - {NodeIndex:571 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+ - {NodeIndex:572 Clocks:0 Vectors:0 Calls:0 Suspends:0}
+Listed 573 node counters
+```
+
+#### Interface stats
+
+Following command will retrieve per interface stats.
+```
+$ ./stats-api interfaces
+Listing interface stats..
+ - {InterfaceIndex:0 RxPackets:0 RxBytes:0 RxErrors:0 TxPackets:0 TxBytes:0 TxErrors:0 RxUnicast:[0 0] RxMulticast:[0 0] RxBroadcast:[0 0] TxUnicastMiss:[0 0] TxMulticast:[0 0] TxBroadcast:[0 0] Drops:0 Punts:0 IP4:0 IP6:0 RxNoBuf:0 RxMiss:0}
+ - {InterfaceIndex:1 RxPackets:0 RxBytes:0 RxErrors:0 TxPackets:0 TxBytes:0 TxErrors:0 RxUnicast:[0 0] RxMulticast:[0 0] RxBroadcast:[0 0] TxUnicastMiss:[0 0] TxMulticast:[0 0] TxBroadcast:[0 0] Drops:5 Punts:0 IP4:0 IP6:0 RxNoBuf:0 RxMiss:0}
+ - {InterfaceIndex:2 RxPackets:0 RxBytes:0 RxErrors:0 TxPackets:0 TxBytes:0 TxErrors:0 RxUnicast:[0 0] RxMulticast:[0 0] RxBroadcast:[0 0] TxUnicastMiss:[0 0] TxMulticast:[0 0] TxBroadcast:[0 0] Drops:0 Punts:0 IP4:0 IP6:0 RxNoBuf:0 RxMiss:0}
+ - {InterfaceIndex:3 RxPackets:0 RxBytes:0 RxErrors:0 TxPackets:0 TxBytes:0 TxErrors:0 RxUnicast:[0 0] RxMulticast:[0 0] RxBroadcast:[0 0] TxUnicastMiss:[0 0] TxMulticast:[0 0] TxBroadcast:[0 0] Drops:0 Punts:0 IP4:0 IP6:0 RxNoBuf:0 RxMiss:0}
+Listed 4 interface counters
+```
+
+#### Error stats
+
+Following command will retrieve error stats.
+Use flag `-all` to include stats with zero values.
+```
+$ ./stats-api errors ip
+Listing error stats.. ip
+ - {ip4-input/ip4 spoofed local-address packet drops 15}
+Listed 1 (825) error counters
+```
+
+### Low-level access to stats
+
+Use commands `ls` and `dump` to list and dump statistics in their raw format
+from [adapter package](../../adapter).
+Optionally, patterns can be used to filter the results.
+
+#### List stats
+
+Following command will list stats matching patterns `/sys/` and `/if/`.
```
$ ./stats-api ls /sys/ /if/
Listing stats.. /sys/ /if/
Listed 25 stats
```
-### Dump all stats with their types and values
+#### Dump stats
+
+Following command will dump stats with their types and actual values.
+Use flag `-all` to include stats with zero values.
```
$ ./stats-api dump
Dumping stats..
"git.fd.io/govpp.git/adapter"
"git.fd.io/govpp.git/adapter/vppapiclient"
+ "git.fd.io/govpp.git/core"
)
// ------------------------------------------------------------------
func init() {
flag.Usage = func() {
- fmt.Fprintf(os.Stderr, "%s: usage [ls|dump] <patterns>...\n", os.Args[0])
+ fmt.Fprintf(os.Stderr, "%s: usage [ls|dump
|errors|interfaces|nodes|system] <patterns>...\n", os.Args[0])
flag.PrintDefaults()
os.Exit(1)
}
func main() {
flag.Parse()
+ skipZeros := !*dumpAll
cmd := flag.Arg(0)
-
switch cmd {
- case "", "ls", "dump":
+ case "", "ls", "dump", "errors", "interfaces", "nodes", "system":
default:
flag.Usage()
}
fmt.Printf("Connecting to stats socket: %s\n", *statsSocket)
- if err := client.Connect(); err != nil {
+ c, err := core.ConnectStats(client)
+ if err != nil {
log.Fatalln("Connecting failed:", err)
}
- defer client.Disconnect()
+ defer c.Disconnect()
switch cmd {
+ case "system":
+ stats, err := c.GetSystemStats()
+ if err != nil {
+ log.Fatalln("getting system stats failed:", err)
+ }
+ fmt.Printf("System stats: %+v\n", stats)
+ case "nodes":
+ fmt.Println("Listing node stats..")
+ stats, err := c.GetNodeStats()
+ if err != nil {
+ log.Fatalln("getting node stats failed:", err)
+ }
+ for _, iface := range stats.Nodes {
+ fmt.Printf(" - %+v\n", iface)
+ }
+ fmt.Printf("Listed %d node counters\n", len(stats.Nodes))
+ case "interfaces":
+ fmt.Println("Listing interface stats..")
+ stats, err := c.GetInterfaceStats()
+ if err != nil {
+ log.Fatalln("getting interface stats failed:", err)
+ }
+ for _, iface := range stats.Interfaces {
+ fmt.Printf(" - %+v\n", iface)
+ }
+ fmt.Printf("Listed %d interface counters\n", len(stats.Interfaces))
+ case "errors":
+ fmt.Printf("Listing error stats.. %s\n", strings.Join(patterns, " "))
+ stats, err := c.GetErrorStats(patterns...)
+ if err != nil {
+ log.Fatalln("getting error stats failed:", err)
+ }
+ n := 0
+ for _, counter := range stats.Errors {
+ if counter.Value == 0 && skipZeros {
+ continue
+ }
+ fmt.Printf(" - %v\n", counter)
+ n++
+ }
+ fmt.Printf("Listed %d (%d) error counters\n", n, len(stats.Errors))
case "dump":
- dumpStats(client, patterns, !*dumpAll)
+ dumpStats(client, patterns, skipZeros)
default:
listStats(client, patterns)
}
Code Review / govpp.git / commitdiff